@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/scatter/ContourScatter.js

@@ -1,116 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { ScatterBase } from "./ScatterBase.js";
-import { contourDensity, descending, geoPath, group, max, quantile, range } from "d3";
-// src/charts/scatter/ContourScatter.ts
-var ScatterContourLevels = /* @__PURE__ */ function(ScatterContourLevels) {
-	ScatterContourLevels["Equal"] = "equal-steps";
-	ScatterContourLevels["Highest"] = "highest-density";
-	return ScatterContourLevels;
-}({});
-var ScatterContourPoints = /* @__PURE__ */ function(ScatterContourPoints) {
-	ScatterContourPoints["All"] = "all-points";
-	ScatterContourPoints["Outliers"] = "outliers-only";
-	ScatterContourPoints["None"] = "contours-only";
-	return ScatterContourPoints;
-}({});
-var ScatterContourScope = /* @__PURE__ */ function(ScatterContourScope) {
-	ScatterContourScope["Overall"] = "overall";
-	ScatterContourScope["PerGroup"] = "per-group";
-	return ScatterContourScope;
-}({});
-var HIGHEST = [
-	.95,
-	.8,
-	.5
-];
-var OUTLIER_SHARE = .06;
-/** Scatter underlaid with kernel density contours, or highest-density regions containing fixed shares. */
-var ContourScatter = class extends ScatterBase {
-	static meta = {
-		id: "contour-scatter",
-		name: "Contour scatter",
-		family: ChartFamily.Relationship,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Draws density contours over a dense scatter so the shape of the cloud is readable.",
-		tags: [
-			"kernel density",
-			"isodensity",
-			"highest density region",
-			"kde2d"
-		],
-		sample: (seed) => SampleData.points(seed, 320, 3),
-		variants: {
-			bandwidth: [
-				16,
-				10,
-				26
-			],
-			levels: ["equal-steps", "highest-density"],
-			steps: [6, 10],
-			showPoints: [
-				"outliers-only",
-				"all-points",
-				"contours-only"
-			],
-			scope: ["overall", "per-group"]
-		},
-		valid: (v) => v.levels === "equal-steps" || v.steps === 6
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			bandwidth: 16,
-			levels: "equal-steps",
-			steps: 6,
-			showPoints: "outliers-only",
-			scope: "overall",
-			radius: 3
-		};
-	}
-	density(point, set) {
-		const sigma = this.options.bandwidth;
-		return set.reduce((sum, other) => sum + Math.exp(-((point.px - other.px) ** 2 + (point.py - other.py) ** 2) / (2 * sigma ** 2)), 0) / (2 * Math.PI * sigma ** 2);
-	}
-	plotPoints(ctx, _axes, points) {
-		const { bandwidth, levels, steps, showPoints, scope } = this.options, { width, height } = ctx.plot;
-		const perGroup = scope === "per-group";
-		const sets = perGroup ? [...group(points, (point) => point.group)] : points.length ? [["All", points]] : [];
-		const estimator = contourDensity().x((d) => d.px).y((d) => d.py).size([width, height]).bandwidth(bandwidth);
-		const layers = sets.flatMap(([key, set]) => {
-			const field = estimator.contours(set);
-			const own = set.map((point) => this.density(point, set)).sort((a, b) => a - b), top = own[own.length - 1] ?? 1;
-			const levelsAt = levels === "highest-density" ? HIGHEST.map((share) => quantile(own, 1 - share) ?? 0) : range(1, steps + 1).map((i) => top * i / (steps + 1));
-			return levelsAt.map((value, i) => ({
-				id: `${key}/${i}`,
-				key,
-				value,
-				share: (i + 1) / levelsAt.length,
-				level: levels === "highest-density" ? HIGHEST[i] : null,
-				shape: field(value * field.max / top)
-			}));
-		});
-		const peak = max(layers, (layer) => layer.share) ?? 1;
-		const tone = (d) => perGroup ? ctx.palette.color(d.key) : ctx.palette.sequential(.15 + d.share / peak * .75);
-		const shapes = ctx.marks("contours", "path", [...layers].sort((a, b) => descending(b.share, a.share)), (d) => d.id).attr("fill", tone).attr("fill-opacity", perGroup ? .1 : .55).attr("stroke", perGroup ? tone : ctx.theme.surface).attr("stroke-width", perGroup ? 1.5 : 1).attr("stroke-linejoin", "round");
-		ctx.set(shapes, { d: (d) => geoPath()(d.shape) });
-		ctx.hover(shapes, (d) => ({
-			title: d.key,
-			color: tone(d),
-			rows: d.level ? [["Contains", `${Math.round(d.level * 100)}%`]] : [["Density", +d.value.toFixed(5)]]
-		}));
-		const sparsest = sets.flatMap(([, set]) => {
-			return set.map((point) => ({
-				point,
-				density: this.density(point, set)
-			})).sort((a, b) => a.density - b.density).slice(0, Math.ceil(set.length * OUTLIER_SHARE)).map((item) => item.point);
-		});
-		const visible = showPoints === "contours-only" ? [] : showPoints === "all-points" ? points : sparsest;
-		this.drawDots(ctx, visible);
-	}
-	legendItems() {
-		return this.options.scope === "per-group" || this.options.showPoints !== "contours-only" ? super.legendItems() : [];
-	}
-};
-export { ContourScatter, ScatterContourLevels, ScatterContourPoints, ScatterContourScope };

package/dist/charts/scatter/GridBinScatter.js

@@ -1,98 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { BinEncoding, BinnedScatterBase } from "./BinnedScatterBase.js";
-import { extent, max, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges } from "d3";
-// src/charts/scatter/GridBinScatter.ts
-var ScatterBinRule = /* @__PURE__ */ function(ScatterBinRule) {
-	ScatterBinRule["Sturges"] = "sturges";
-	ScatterBinRule["Scott"] = "scott";
-	ScatterBinRule["FreedmanDiaconis"] = "freedman-diaconis";
-	return ScatterBinRule;
-}({});
-var ScatterGridCell = /* @__PURE__ */ function(ScatterGridCell) {
-	ScatterGridCell["Square"] = "square-cells";
-	ScatterGridCell["Circle"] = "circle-cells";
-	return ScatterGridCell;
-}({});
-var RULES = {
-	["sturges"]: thresholdSturges,
-	["scott"]: thresholdScott,
-	["freedman-diaconis"]: thresholdFreedmanDiaconis
-};
-/** A two-dimensional histogram over x/y, with statistical bin-width rules. */
-var GridBinScatter = class extends BinnedScatterBase {
-	static meta = {
-		id: "gridbin-scatter",
-		name: "Grid-binned scatter",
-		family: ChartFamily.Relationship,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Counts x/y points in a rectangular grid chosen by a statistical bin-width rule.",
-		tags: [
-			"2d histogram",
-			"heatmap",
-			"binned scatter"
-		],
-		sample: (seed) => SampleData.points(seed, 700, 3),
-		variants: {
-			rule: [
-				"scott",
-				"sturges",
-				"freedman-diaconis"
-			],
-			encoding: [BinEncoding.Color, BinEncoding.Both],
-			cell: ["square-cells", "circle-cells"],
-			raw: [false, true]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			rule: "scott",
-			cell: "square-cells"
-		};
-	}
-	plotPoints(ctx, _axes, points) {
-		const { rule, cell } = this.options, { width, height } = ctx.plot;
-		const divisions = (values, top) => {
-			const [low = 0, high = top] = extent(values);
-			return Math.max(2, Math.min(40, RULES[rule](values, low, high) || 2));
-		};
-		const columns = divisions(points.map((p) => p.px), width), rows = divisions(points.map((p) => p.py), height);
-		const cw = width / columns, ch = height / rows;
-		const cells = /* @__PURE__ */ new Map();
-		for (const point of points) {
-			const col = Math.min(columns - 1, Math.floor(point.px / cw)), row = Math.min(rows - 1, Math.floor(point.py / ch)), key = `${col}/${row}`;
-			if (!cells.has(key)) cells.set(key, {
-				col,
-				row,
-				points: []
-			});
-			cells.get(key).points.push(point);
-		}
-		const list = [...cells.values()], peak = max(list, (d) => d.points.length) ?? 1;
-		const span = (d) => this.extent(this.share(d.points.length, peak));
-		const color = (d) => this.shade(ctx, this.share(d.points.length, peak));
-		const key = (d) => `${d.col}/${d.row}`;
-		this.drawRaw(ctx, points);
-		const squares = ctx.marks("squares", "rect", cell === "square-cells" ? list : [], key).attr("fill", color).attr("rx", 2);
-		ctx.set(squares, {
-			x: (d) => (d.col + .5 - span(d) / 2) * cw + 1,
-			y: (d) => (d.row + .5 - span(d) / 2) * ch + 1,
-			width: (d) => Math.max(1, cw * span(d) - 2),
-			height: (d) => Math.max(1, ch * span(d) - 2)
-		});
-		const circles = ctx.marks("circles", "circle", cell === "circle-cells" ? list : [], key).attr("fill", color);
-		ctx.set(circles, {
-			cx: (d) => (d.col + .5) * cw,
-			cy: (d) => (d.row + .5) * ch,
-			r: (d) => Math.max(1, (Math.min(cw, ch) / 2 - 1) * span(d))
-		});
-		for (const marks of [squares, circles]) ctx.hover(marks, (d) => ({
-			title: `${d.points.length} points`,
-			color: color(d)
-		}));
-		this.drawCountKey(ctx, points, peak, (t) => this.shade(ctx, t));
-	}
-};
-export { GridBinScatter, ScatterBinRule, ScatterGridCell };

package/dist/charts/scatter/HexbinScatter.js

@@ -1,74 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { BinCount, BinEncoding, BinnedScatterBase } from "./BinnedScatterBase.js";
-import { max } from "d3";
-import { hexbin } from "d3-hexbin";
-// src/charts/scatter/HexbinScatter.ts
-/** Hexagonal binning for overplotted scatters: thousands of points become a count surface. */
-var HexbinScatter = class extends BinnedScatterBase {
-	static meta = {
-		id: "hexbin-scatter",
-		name: "Hexbin scatter",
-		family: ChartFamily.Relationship,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Bins dense x/y points into hexagons and shows the count in each.",
-		tags: [
-			"hexagonal binning",
-			"density",
-			"overplotting",
-			"big data"
-		],
-		sample: (seed) => SampleData.points(seed, 900, 3),
-		variants: {
-			encoding: [BinEncoding.Color, BinEncoding.Both],
-			count: [
-				BinCount.Linear,
-				BinCount.Sqrt,
-				BinCount.Log
-			],
-			binRadius: [
-				11,
-				7,
-				16
-			],
-			lattice: [false, true],
-			raw: [false, true]
-		},
-		valid: (v) => v.encoding !== BinEncoding.Color || v.count === BinCount.Linear
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			binRadius: 11,
-			lattice: false
-		};
-	}
-	inset() {
-		return this.options.binRadius;
-	}
-	plotPoints(ctx, _axes, points) {
-		const { width, height } = ctx.plot, { binRadius, lattice } = this.options;
-		const layout = hexbin().x((d) => d.px).y((d) => d.py).radius(binRadius).extent([[binRadius, binRadius], [width - binRadius, height - binRadius]]);
-		const bins = layout(points).map((bin) => bin);
-		const peak = max(bins, (bin) => bin.length) ?? 1;
-		const mesh = ctx.marks("lattice", "path", lattice ? [layout.mesh()] : []).attr("fill", "none").attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
-		ctx.set(mesh, { d: (d) => d });
-		this.drawRaw(ctx, points);
-		const inner = Math.max(1, binRadius - 1);
-		const hexes = ctx.marks("hexes", "path", bins, (bin) => `${bin.x},${bin.y}`).attr("fill", (bin) => this.shade(ctx, this.share(bin.length, peak))).attr("stroke", ctx.theme.surface).attr("stroke-width", 1);
-		ctx.set(hexes, {
-			d: (bin) => layout.hexagon(inner * this.extent(this.share(bin.length, peak))),
-			transform: (bin) => `translate(${bin.x},${bin.y})`
-		}, {
-			transform: (bin) => `translate(${bin.x},${bin.y})`,
-			d: layout.hexagon(.01)
-		}, 1);
-		ctx.hover(hexes, (bin) => ({
-			title: `${bin.length} points`,
-			color: this.shade(ctx, this.share(bin.length, peak))
-		}));
-		this.drawCountKey(ctx, points, peak, (t) => this.shade(ctx, t));
-	}
-};
-export { HexbinScatter };

package/dist/charts/scatter/StripScatter.js

@@ -1,107 +0,0 @@
-import { ChartFamily, DataShape, Dimension, Orientation, ScaleKind } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { CategoryScatterBase, CategorySort, CategorySummary } from "./CategoryScatterBase.js";
-// src/charts/scatter/StripScatter.ts
-var StripScatterMark = /* @__PURE__ */ function(StripScatterMark) {
-	StripScatterMark["Tick"] = "tick";
-	StripScatterMark["Dot"] = "dot";
-	StripScatterMark["Diamond"] = "diamond";
-	return StripScatterMark;
-}({});
-/** Every observation on one line per category: the tidiest view for modest samples. */
-var StripScatter = class extends CategoryScatterBase {
-	static meta = {
-		id: "strip-scatter",
-		name: "Strip plot",
-		family: ChartFamily.Distribution,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Lines up every observation along one axis per category, showing spread without binning.",
-		tags: [
-			"barcode",
-			"tick plot",
-			"one-dimensional"
-		],
-		sample: (seed) => SampleData.distribution(seed, 50, 4),
-		variants: {
-			orientation: [Orientation.Horizontal, Orientation.Vertical],
-			mark: [
-				"tick",
-				"dot",
-				"diamond"
-			],
-			scale: [ScaleKind.Linear, ScaleKind.Log],
-			sort: [CategorySort.Data, CategorySort.Descending],
-			summary: [
-				CategorySummary.None,
-				CategorySummary.Median,
-				CategorySummary.Box
-			],
-			thickness: [.5, .8]
-		},
-		valid: (v) => v.mark === "tick" || v.thickness === .5
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			orientation: Orientation.Horizontal,
-			mark: "tick",
-			thickness: .5
-		};
-	}
-	plotLanes(ctx, axes, lanes) {
-		const { mark, thickness } = this.options, vertical = this.vertical;
-		const placed = lanes.flatMap((lane) => lane.points.map((point) => ({
-			...point,
-			center: lane.center,
-			half: lane.breadth / 2 * thickness
-		})));
-		const color = (d) => ctx.palette.color(d.group);
-		const along = (d) => axes.value(d.value);
-		const ticks = ctx.marks("ticks", "line", mark === "tick" ? placed : [], (d) => d.index).attr("stroke", color).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke-opacity", .7);
-		ctx.set(ticks, vertical ? {
-			x1: (d) => d.center - d.half,
-			x2: (d) => d.center + d.half,
-			y1: along,
-			y2: along
-		} : {
-			y1: (d) => d.center - d.half,
-			y2: (d) => d.center + d.half,
-			x1: along,
-			x2: along
-		}, vertical ? {
-			x1: (d) => d.center,
-			x2: (d) => d.center,
-			y1: along,
-			y2: along
-		} : {
-			y1: (d) => d.center,
-			y2: (d) => d.center,
-			x1: along,
-			x2: along
-		}, 1);
-		ctx.hover(ticks, (d) => this.tooltip(ctx, d));
-		const glyphs = ctx.marks("glyphs", "rect", mark === "diamond" ? placed : [], (d) => d.index).attr("fill", color).attr("fill-opacity", .8);
-		const spot = (d) => vertical ? [d.center, along(d)] : [along(d), d.center];
-		ctx.set(glyphs, {
-			x: -4,
-			y: -4,
-			width: 8,
-			height: 8,
-			transform: (d) => `translate(${spot(d)[0]},${spot(d)[1]}) rotate(45)`
-		});
-		ctx.hover(glyphs, (d) => this.tooltip(ctx, d));
-		const dots = ctx.marks("dots", "circle", mark === "dot" ? placed : [], (d) => d.index).attr("fill", color).attr("fill-opacity", .65);
-		ctx.set(dots, {
-			cx: (d) => spot(d)[0],
-			cy: (d) => spot(d)[1],
-			r: this.options.radius
-		}, {
-			cx: (d) => spot(d)[0],
-			cy: (d) => spot(d)[1],
-			r: 0
-		});
-		ctx.hover(dots, (d) => this.tooltip(ctx, d));
-	}
-};
-export { StripScatter, StripScatterMark };

package/dist/charts/scatter/SunflowerScatter.js

@@ -1,109 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { ScatterBase } from "./ScatterBase.js";
-import { hexbin } from "d3-hexbin";
-// src/charts/scatter/SunflowerScatter.ts
-var SunflowerScatterPetal = /* @__PURE__ */ function(SunflowerScatterPetal) {
-	SunflowerScatterPetal["Line"] = "line-petals";
-	SunflowerScatterPetal["Leaf"] = "leaf-petals";
-	return SunflowerScatterPetal;
-}({});
-var SunflowerLattice = /* @__PURE__ */ function(SunflowerLattice) {
-	SunflowerLattice["Hex"] = "hex-lattice";
-	SunflowerLattice["Square"] = "square-lattice";
-	return SunflowerLattice;
-}({});
-var MAX_PETALS = 16;
-/** Counts overplotted points by petals on a glyph, staying readable as discrete units. */
-var SunflowerScatter = class extends ScatterBase {
-	static meta = {
-		id: "sunflower-scatter",
-		name: "Sunflower scatter",
-		family: ChartFamily.Relationship,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Replaces clumps of overlapping points with glyphs whose petals count the observations.",
-		tags: [
-			"sunflower plot",
-			"overplotting",
-			"count glyph"
-		],
-		sample: (seed) => SampleData.points(seed, 380, 3),
-		variants: {
-			cell: [
-				13,
-				9,
-				18
-			],
-			unit: [1, 3],
-			petal: ["line-petals", "leaf-petals"],
-			lattice: ["hex-lattice", "square-lattice"]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			cell: 13,
-			unit: 1,
-			petal: "line-petals",
-			lattice: "hex-lattice"
-		};
-	}
-	inset() {
-		return this.options.cell;
-	}
-	legendItems() {
-		return [];
-	}
-	flowers(points) {
-		const { cell, unit, lattice } = this.options;
-		const pack = (x, y, count) => ({
-			id: `${x},${y}`,
-			x,
-			y,
-			count,
-			petals: Math.min(MAX_PETALS, Math.round(count / unit))
-		});
-		if (lattice === "hex-lattice") return hexbin().x((d) => d.px).y((d) => d.py).radius(cell)(points).map((bin) => pack(bin.x, bin.y, bin.length));
-		const size = cell * 1.8, cells = /* @__PURE__ */ new Map();
-		for (const point of points) {
-			const key = `${Math.floor(point.px / size)}/${Math.floor(point.py / size)}`;
-			cells.set(key, [...cells.get(key) ?? [], point]);
-		}
-		return [...cells].map(([key, set]) => {
-			const [c, r] = key.split("/").map(Number);
-			return pack((c + .5) * size, (r + .5) * size, set.length);
-		});
-	}
-	glyph(petals) {
-		if (petals < 2) return "";
-		const reach = this.options.cell * .82, core = 2.5;
-		return Array.from({ length: petals }, (_, i) => {
-			const t = i / petals * Math.PI * 2 - Math.PI / 2, c = Math.cos(t), s = Math.sin(t);
-			if (this.options.petal === "line-petals") return `M${core * c},${core * s}L${reach * c},${reach * s}`;
-			const mx = (reach + core) / 2 * c, my = (reach + core) / 2 * s, w = 2.2;
-			return `M${core * c},${core * s}Q${mx - s * w},${my + c * w} ${reach * c},${reach * s}Q${mx + s * w},${my - c * w} ${core * c},${core * s}Z`;
-		}).join("");
-	}
-	plotPoints(ctx, _axes, points) {
-		const flowers = this.flowers(points), ink = ctx.palette.sequential(.68);
-		const leaf = this.options.petal === "leaf-petals";
-		const glyphs = ctx.marks("flowers", "path", flowers, (d) => d.id).attr("fill", leaf ? ink : "none").attr("stroke", ink).attr("stroke-width", leaf ? .5 : 1.5).attr("stroke-linecap", "round");
-		ctx.set(glyphs, {
-			d: (d) => this.glyph(d.petals),
-			transform: (d) => `translate(${d.x},${d.y})`
-		});
-		ctx.hover(glyphs, (d) => ({
-			title: `${d.count} points`,
-			color: ink,
-			rows: [["Petals", d.petals]]
-		}));
-		const hearts = ctx.marks("hearts", "circle", flowers, (d) => d.id).attr("fill", ink);
-		ctx.set(hearts, {
-			cx: (d) => d.x,
-			cy: (d) => d.y,
-			r: 2.5
-		});
-	}
-};
-export { SunflowerLattice, SunflowerScatter, SunflowerScatterPetal };

package/dist/charts/signals/ConstellationChart.js

@@ -1,153 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { SignalChart } from "./SignalChart.js";
-import { SignalRaster } from "./SignalRaster.js";
-import { SignalScales } from "./SignalScales.js";
-import { max, scaleLinear } from "d3";
-// src/charts/signals/ConstellationChart.ts
-var ConstellationDisplay = /* @__PURE__ */ function(ConstellationDisplay) {
-	ConstellationDisplay["Points"] = "points";
-	ConstellationDisplay["Density"] = "density";
-	ConstellationDisplay["Path"] = "symbol-path";
-	return ConstellationDisplay;
-}({});
-var CELL = 4;
-var LEVELS = 4;
-/** I/Q scatter of a digital modulation, for reading noise, compression and phase error at a glance. */
-var ConstellationChart = class extends SignalChart {
-	static meta = {
-		id: "signal-constellation",
-		name: "Constellation diagram",
-		family: ChartFamily.Scientific,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Plots received I/Q symbols around their ideal points to diagnose noise and distortion in digital modulation.",
-		tags: [
-			"iq",
-			"qam",
-			"qpsk",
-			"evm",
-			"modulation"
-		],
-		sample: (seed) => {
-			const noise = SampleData.points(seed, 256, 1), mean = noise.reduce((sum, row) => sum + +row.x, 0) / noise.length;
-			const rail = (value) => [
-				-3,
-				-1,
-				1,
-				3
-			][Math.abs(Math.floor(value * 7)) % 4];
-			return noise.map((row, i) => {
-				const [a, b] = [(+row.x - mean) / 8, (+row.y - +row.x * .8 - 10) / 9];
-				return {
-					i: +((rail(+row.size * (i + 3)) + a * .14) / 3.3).toFixed(4),
-					q: +((rail(+row.y * (i + 5)) + b * .14) / 3.3).toFixed(4)
-				};
-			});
-		},
-		variants: {
-			display: Object.values(ConstellationDisplay),
-			decision: [true, false],
-			errors: [false, true],
-			ring: [false, true]
-		},
-		valid: (values) => values.errors === false || values.display === "points"
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			x: "i",
-			y: "q",
-			xLabel: "In-phase",
-			yLabel: "Quadrature",
-			grid: false,
-			display: "points",
-			levels: LEVELS,
-			decision: true,
-			errors: false,
-			ring: false
-		};
-	}
-	get legended() {
-		return false;
-	}
-	get symbols() {
-		const { data, x, y, levels } = this.options, rows = (data ?? []).filter((row) => Number.isFinite(+row[x]) && Number.isFinite(+row[y]) && row[x] !== null && row[y] !== null);
-		const reach = Math.max(1e-9, ...rows.map((row) => Math.max(Math.abs(+row[x]), Math.abs(+row[y]))));
-		const count = levels, unit = reach * .96 / (count - 1);
-		const snap = (value) => (Math.max(0, Math.min(count - 1, Math.round((value / unit + count - 1) / 2))) * 2 - (count - 1)) * unit;
-		return rows.map((row, key) => ({
-			key,
-			i: +row[x],
-			q: +row[y],
-			idealI: snap(+row[x]),
-			idealQ: snap(+row[y]),
-			rail: unit
-		}));
-	}
-	scales(ctx) {
-		const { width, height } = ctx.plot, symbols = this.symbols;
-		const outer = symbols[0] ? (this.options.levels - 1) * symbols[0].rail : 1, ring = this.options.ring ? Math.SQRT2 * outer * 1.03 : 0;
-		const reach = Math.max(ring, Math.max(1, ...symbols.map((symbol) => Math.max(Math.abs(symbol.i), Math.abs(symbol.q)))) * 1.1), ratio = width / height;
-		return {
-			x: scaleLinear([-reach * ratio, reach * ratio], [0, width]),
-			y: scaleLinear([-reach, reach], [height, 0])
-		};
-	}
-	plotMarks(ctx, { x, y }) {
-		const { display, decision, errors, ring, levels } = this.options, { width, height } = ctx.plot, symbols = this.symbols, unit = symbols[0]?.rail ?? .3;
-		const color = ctx.palette.color("Symbols");
-		const rails = Array.from({ length: levels - 1 }, (_, i) => (i * 2 - (levels - 2)) * unit);
-		if (decision) {
-			ctx.marks("decision-x", "line", rails, (rail) => rail).attr("x1", (rail) => x(rail)).attr("x2", (rail) => x(rail)).attr("y1", 0).attr("y2", height).attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
-			ctx.marks("decision-y", "line", rails, (rail) => rail).attr("x1", 0).attr("x2", width).attr("y1", (rail) => y(rail)).attr("y2", (rail) => y(rail)).attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
-		}
-		ctx.marks("axes", "path", [0]).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("d", `M${x(0)} 0V${height}M0 ${y(0)}H${width}`);
-		if (ring) {
-			const reach = Math.hypot(1, 1) * (levels - 1) * unit, step = Math.abs(x(1) - x(0));
-			ctx.marks("ring", "circle", [reach], (_, i) => i).attr("cx", x(0)).attr("cy", y(0)).attr("r", reach * step).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("stroke-dasharray", "4 3");
-		}
-		if (display === "density") this.density(ctx, symbols, x, y);
-		if (display === "symbol-path") this.stroke(ctx, "path", [symbols.slice(0, 64)], () => 0, (list) => this.path(list.map((symbol) => [symbol.i, symbol.q]), x, y), () => color, 1).attr("stroke-opacity", .55);
-		if (errors) ctx.marks("errors", "line", symbols, (symbol) => symbol.key).attr("stroke", ctx.theme.inkSecondary).attr("stroke-width", 1).attr("x1", (symbol) => x(symbol.idealI)).attr("y1", (symbol) => y(symbol.idealQ)).attr("x2", (symbol) => x(symbol.i)).attr("y2", (symbol) => y(symbol.q));
-		if (display !== "density") {
-			const list = display === "symbol-path" ? symbols.slice(0, 64) : symbols;
-			const dots = ctx.marks("symbols", "circle", list, (symbol) => symbol.key).attr("fill", color).attr("stroke", ctx.theme.surface).attr("stroke-width", 1);
-			ctx.set(dots, {
-				cx: (symbol) => x(symbol.i),
-				cy: (symbol) => y(symbol.q),
-				r: 4
-			}, { r: 0 }, 2);
-			ctx.hover(dots, (symbol) => ({
-				title: `Symbol ${symbol.key + 1}`,
-				color,
-				rows: [
-					["I", SignalScales.number(symbol.i)],
-					["Q", SignalScales.number(symbol.q)],
-					["Error", SignalScales.number(Math.hypot(symbol.i - symbol.idealI, symbol.q - symbol.idealQ))]
-				]
-			}));
-		}
-		const rms = Math.sqrt(symbols.reduce((sum, symbol) => sum + (symbol.i - symbol.idealI) ** 2 + (symbol.q - symbol.idealQ) ** 2, 0) / (symbols.reduce((sum, symbol) => sum + symbol.idealI ** 2 + symbol.idealQ ** 2, 0) || 1));
-		if (symbols.length) ctx.text(ctx.marks("evm", "text", [0]).attr("x", width - 4).attr("y", 12).attr("text-anchor", "end").text(`EVM ${(rms * 100).toFixed(1)}%`), 11, "ink");
-	}
-	density(ctx, symbols, x, y) {
-		const { width, height } = ctx.plot, columns = Math.ceil(width / CELL), rows = Math.ceil(height / CELL), counts = new Array(columns * rows).fill(0), blur = 2;
-		for (const symbol of symbols) {
-			const c = Math.floor(x(symbol.i) / CELL), r = Math.floor(y(symbol.q) / CELL);
-			for (let dr = -2; dr <= blur; dr++) for (let dc = -2; dc <= blur; dc++) if (c + dc >= 0 && c + dc < columns && r + dr >= 0 && r + dr < rows) counts[(r + dr) * columns + c + dc] += Math.exp(-(dr * dr + dc * dc) / 3);
-		}
-		const top = max(counts) || 1, cells = [];
-		counts.forEach((count, i) => {
-			if (count / top > .04) cells.push({
-				x: i % columns * CELL,
-				y: Math.floor(i / columns) * CELL,
-				width: CELL,
-				height: CELL,
-				level: Math.sqrt(count / top)
-			});
-		});
-		SignalRaster.paint(ctx, "density", cells, ctx.palette.sequential);
-	}
-};
-export { ConstellationChart, ConstellationDisplay };