@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/hierarchy/TreemapSkyline3D.js

@@ -1,98 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { Hierarchy3DChart } from "./Hierarchy3DChart.js";
-import { HierarchyMeasure, SkylineHeight, TreemapTile } from "./hierarchyEnums.js";
-import { treemapTiling } from "./TreemapTiling.js";
-import { TreeSamples } from "./TreeSamples.js";
-import { max, treemap } from "d3";
-import { BoxGeometry, InstancedMesh, Mesh, MeshStandardMaterial, Object3D, PlaneGeometry } from "three";
-// src/charts/hierarchy/TreemapSkyline3D.ts
-var FLOOR = -.7;
-var STEP = .05;
-var TOP = 1.3;
-/** Treemap extruded into a city: footprint and height can carry two measures of the same items. */
-var TreemapSkyline3D = class extends Hierarchy3DChart {
-	static meta = {
-		id: "treemap-skyline-3d",
-		name: "3D treemap skyline",
-		family: ChartFamily.Hierarchy,
-		dimension: Dimension.Three,
-		shape: DataShape.Hierarchy,
-		description: "Extrudes treemap cells into a city, so footprint and height can carry different views of the same items.",
-		tags: [
-			"city",
-			"extruded treemap",
-			"skyline",
-			"software city"
-		],
-		sample: (seed) => TreeSamples.broad(seed, 3, 4),
-		variants: {
-			tile: [
-				TreemapTile.Squarify,
-				TreemapTile.Binary,
-				TreemapTile.SliceDice
-			],
-			heightBy: Object.values(SkylineHeight),
-			terraces: [true, false],
-			measure: [HierarchyMeasure.Value, HierarchyMeasure.LeafCount]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			tile: TreemapTile.Squarify,
-			heightBy: SkylineHeight.Value,
-			terraces: true
-		};
-	}
-	buildTree(ctx) {
-		const { tile, heightBy, terraces } = this.options;
-		const gap = .012;
-		const root = treemap().size([2, 2]).tile(treemapTiling(tile)).paddingInner(gap).paddingOuter((node) => terraces && node.depth > 0 ? gap * 2 : 0)(this.tree());
-		const cells = root.leaves();
-		const groups = terraces ? root.descendants().filter((node) => node.depth > 0 && node.children) : [];
-		const peak = max(cells, (cell) => cell.data.total) || 1;
-		const rise = (cell) => {
-			const share = cell.data.total / peak;
-			if (heightBy === SkylineHeight.Depth) return .06 + .5 * share * (cell.depth / Math.max(1, root.height));
-			return Math.max(.02, TOP * (heightBy === SkylineHeight.Sqrt ? Math.sqrt(share) : share));
-		};
-		const base = (node) => FLOOR + (terraces ? (node.depth - 1) * STEP : 0);
-		const floor = new Mesh(new PlaneGeometry(2.3, 2.3), new MeshStandardMaterial({ color: ctx.theme.grid }));
-		floor.rotation.x = -Math.PI / 2;
-		floor.position.y = -.701;
-		floor.receiveShadow = true;
-		ctx.root.add(floor);
-		const dummy = new Object3D();
-		const box = new BoxGeometry(1, 1, 1);
-		const plinths = groups.length ? new InstancedMesh(box.clone(), new MeshStandardMaterial({ roughness: .8 }), groups.length) : null;
-		groups.forEach((group, i) => {
-			dummy.position.set((group.x0 + group.x1) / 2 - 1, base(group) + STEP / 2, (group.y0 + group.y1) / 2 - 1);
-			dummy.scale.set(group.x1 - group.x0, STEP, group.y1 - group.y0);
-			dummy.updateMatrix();
-			plinths.setMatrixAt(i, dummy.matrix);
-			plinths.setColorAt(i, ctx.color(this.style.tint(this.style.branch(group), .72 - .2 * (group.depth - 1))));
-		});
-		if (plinths) {
-			plinths.receiveShadow = true;
-			ctx.root.add(plinths);
-			ctx.pick(plinths, (i) => this.style.tooltip(groups[i]));
-		}
-		const towers = new InstancedMesh(box, new MeshStandardMaterial({ roughness: .55 }), cells.length);
-		towers.castShadow = towers.receiveShadow = true;
-		cells.forEach((cell, i) => towers.setColorAt(i, ctx.color(this.style.fill(cell))));
-		ctx.reveal((progress) => {
-			cells.forEach((cell, i) => {
-				const tall = Math.max(.001, rise(cell) * progress);
-				const floorY = base(cell) + (terraces ? STEP : 0);
-				dummy.position.set((cell.x0 + cell.x1) / 2 - 1, floorY + tall / 2, (cell.y0 + cell.y1) / 2 - 1);
-				dummy.scale.set(cell.x1 - cell.x0, tall, cell.y1 - cell.y0);
-				dummy.updateMatrix();
-				towers.setMatrixAt(i, dummy.matrix);
-			});
-			towers.instanceMatrix.needsUpdate = true;
-		});
-		ctx.root.add(towers);
-		ctx.pick(towers, (i) => this.style.tooltip(cells[i]));
-	}
-};
-export { TreemapSkyline3D };

package/dist/charts/linesareas/ConnectedScatterTime.js

@@ -1,206 +0,0 @@
-import { CartesianChart } from "../../core/CartesianChart.js";
-import { ChartFamily, CurveKind, DataShape, Dimension, LegendPosition, ScaleKind } from "../../core/enums.js";
-import { Scales } from "../../core/Scales.js";
-import { SampleData } from "../../data/SampleData.js";
-import { ConnectedDates, ConnectedDots } from "./LineEnums.js";
-import { TrendHover } from "./TrendHover.js";
-import { TrendLabels } from "./TrendLabels.js";
-import { TrendTable } from "./TrendTable.js";
-import { extent, group, line, utcFormat } from "d3";
-// src/charts/linesareas/ConnectedScatterTime.ts
-var dateLabel = utcFormat("%b %-d");
-/** Two measures moving together through time, where the loops of the path are the story. Needs a reader willing to follow direction. */
-var ConnectedScatterTime = class ConnectedScatterTime extends CartesianChart {
-	static meta = {
-		id: "connected-scatter-time",
-		name: "Connected scatter over time",
-		family: ChartFamily.Relationship,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Joins x-y points in time order, so that the path shows how two measures move together.",
-		tags: [
-			"phase plot",
-			"path",
-			"trajectory"
-		],
-		sample: (seed) => {
-			const rows = SampleData.timeSeries(seed, 26, 2);
-			const half = rows.length / 2;
-			return rows.slice(0, half).map((row, i) => ({
-				date: row.date,
-				x: row.value,
-				y: rows[half + i].value
-			}));
-		},
-		variants: {
-			curve: [
-				CurveKind.CatmullRom,
-				CurveKind.Linear,
-				CurveKind.Cardinal,
-				CurveKind.Basis
-			],
-			dots: [
-				ConnectedDots.Ends,
-				ConnectedDots.All,
-				ConnectedDots.None
-			],
-			dates: [
-				ConnectedDates.Ends,
-				ConnectedDates.Periodic,
-				ConnectedDates.None
-			],
-			arrows: [true, false],
-			scale: [ScaleKind.Linear, ScaleKind.Log]
-		}
-	};
-	defaults() {
-		return {
-			x: "x",
-			y: "y",
-			time: "date",
-			series: "series",
-			curve: CurveKind.CatmullRom,
-			scale: ScaleKind.Linear,
-			dots: ConnectedDots.Ends,
-			dates: ConnectedDates.Ends,
-			arrows: true
-		};
-	}
-	get log() {
-		return this.options.scale === ScaleKind.Log;
-	}
-	get legendPosition() {
-		return this.trails.length > 1 ? super.legendPosition : LegendPosition.None;
-	}
-	static moment(cell) {
-		if (cell instanceof Date) return +cell;
-		if (typeof cell === "number") return cell;
-		if (typeof cell !== "string" || !cell) return null;
-		const parsed = +new Date(cell);
-		return Number.isNaN(parsed) ? null : parsed;
-	}
-	get trails() {
-		const { data, x, y, time, series } = this.options;
-		const parsed = (Array.isArray(data) ? data : []).flatMap((row) => {
-			const at = ConnectedScatterTime.moment(row[time]), a = TrendTable.number(row[x]), b = TrendTable.number(row[y]);
-			if (at === null || a === null || b === null || this.log && (a <= 0 || b <= 0)) return [];
-			const label = row[time] instanceof Date ? dateLabel(row[time]) : String(row[time]);
-			return [{
-				key: `${row[series] ?? ""}/${at}`,
-				name: String(row[series] ?? y),
-				x: a,
-				y: b,
-				time: at,
-				label
-			}];
-		});
-		return [...group(parsed, (d) => d.name)].map(([key, items]) => {
-			const sorted = [...items].sort((a, b) => a.time - b.time);
-			return {
-				key,
-				stops: sorted.map((d, i) => ({
-					...d,
-					share: sorted.length > 1 ? i / (sorted.length - 1) : 1,
-					position: i
-				}))
-			};
-		});
-	}
-	axis(values, range) {
-		const [lo = this.log ? 1 : 0, hi = this.log ? 10 : 1] = extent(values);
-		const pad = (hi - lo) * .05 || Math.abs(lo) * .1 || 1;
-		const scale = Scales.continuous(this.options.scale).domain(this.log ? [lo / 1.05, hi * 1.05] : [lo - pad, hi + pad]).range(range);
-		return this.log ? scale : scale.nice();
-	}
-	scales(ctx) {
-		const stops = this.trails.flatMap((trail) => trail.stops);
-		return {
-			x: this.axis(stops.map((s) => s.x), [0, ctx.plot.width]),
-			y: this.axis(stops.map((s) => s.y), [ctx.plot.height, 0])
-		};
-	}
-	/** Where the drawn curve really passes a stop: B-splines cut inside their control points. */
-	onCurve(stops, i) {
-		const here = stops[i];
-		if (this.options.curve !== CurveKind.Basis) return here;
-		const before = stops[i - 1] ?? here, after = stops[i + 1] ?? here;
-		return [(before[0] + 4 * here[0] + after[0]) / 6, (before[1] + 4 * here[1] + after[1]) / 6];
-	}
-	plotMarks(ctx, axes) {
-		const { curve, dots, dates, arrows } = this.options;
-		const trails = this.trails;
-		const single = trails.length === 1;
-		const cx = (s) => axes.x(s.x) ?? 0, cy = (s) => axes.y(s.y) ?? 0;
-		const path = line().x(cx).y(cy).curve(Scales.curve(curve));
-		const lines = ctx.marks("lines", "path", trails, (t) => t.key).attr("fill", "none").attr("stroke", (t) => ctx.palette.color(t.key)).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
-		lines.filter(function() {
-			return !this.getAttribute("d");
-		}).attr("d", (t) => path(t.stops) ?? "");
-		ctx.drawOn(lines);
-		ctx.set(lines, { d: (t) => path(t.stops) ?? "" });
-		const heads = trails.flatMap((trail) => {
-			const at = trail.stops.map((s) => [cx(s), cy(s)]);
-			const every = Math.max(2, Math.ceil(at.length / 6));
-			return arrows ? trail.stops.flatMap((stop, i) => {
-				if (i === 0 || i >= at.length - 1 || i % every) return [];
-				const before = this.onCurve(at, i - 1), after = this.onCurve(at, i + 1), place = this.onCurve(at, i);
-				return [{
-					key: stop.key,
-					color: ctx.palette.color(trail.key),
-					x: place[0],
-					y: place[1],
-					angle: Math.atan2(after[1] - before[1], after[0] - before[0]) * 180 / Math.PI
-				}];
-			}) : [];
-		});
-		const arrowMarks = ctx.marks("arrows", "path", heads, (d) => d.key).attr("fill", (d) => d.color).attr("stroke", ctx.theme.surface).attr("stroke-width", 1).attr("d", "M-6,-5L6,0L-6,5L-3,0Z");
-		ctx.set(arrowMarks, { transform: (d) => `translate(${d.x},${d.y}) rotate(${d.angle})` });
-		const dotted = trails.flatMap((trail) => trail.stops.filter((s, i) => dots === ConnectedDots.All || dots === ConnectedDots.Ends && (i === 0 || i === trail.stops.length - 1)).map((stop) => ({
-			stop,
-			trail
-		})));
-		const marks = ctx.marks("dots", "circle", dotted, (d) => d.stop.key).attr("stroke", ctx.theme.surface).attr("stroke-width", 2).attr("fill", (d) => single ? ctx.palette.sequential(.3 + d.stop.share * .7) : ctx.palette.color(d.trail.key));
-		ctx.set(marks, {
-			cx: (d) => cx(d.stop),
-			cy: (d) => cy(d.stop),
-			r: 5
-		}, {
-			cx: (d) => cx(d.stop),
-			cy: (d) => cy(d.stop),
-			r: 0
-		});
-		const noted = dates === ConnectedDates.None ? [] : trails.flatMap((trail) => {
-			const every = Math.max(1, Math.ceil(trail.stops.length / 5)), last = trail.stops.length - 1;
-			return trail.stops.filter((_, i) => i === 0 || i === last || dates === ConnectedDates.Periodic && i % every === 0).map((stop) => {
-				const w = stop.label.length * 6.2;
-				return {
-					key: stop.key,
-					text: stop.label,
-					w,
-					h: 12,
-					x: Math.max(w / 2, Math.min(ctx.plot.width - w / 2, cx(stop))),
-					y: cy(stop) < 18 ? cy(stop) + 15 : cy(stop) - 13
-				};
-			});
-		});
-		const notes = ctx.text(ctx.marks("dates", "text", TrendLabels.reject(noted), (d) => d.key), 11, "ink").attr("text-anchor", "middle").attr("dy", ".32em").attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3).text((d) => d.text);
-		ctx.set(notes, {
-			x: (d) => d.x,
-			y: (d) => d.y
-		}, {
-			x: (d) => d.x,
-			y: (d) => d.y
-		});
-		const stops = trails.flatMap((trail) => trail.stops.map((stop) => ({
-			stop,
-			trail
-		})));
-		const hits = ctx.marks("hits", "circle", stops, (d) => d.stop.key).attr("fill", "transparent").attr("r", 12).attr("cx", (d) => cx(d.stop)).attr("cy", (d) => cy(d.stop));
-		ctx.hover(hits, ({ stop, trail }) => ({
-			title: stop.label,
-			color: ctx.palette.color(trail.key),
-			rows: [[this.options.xLabel ?? this.options.x, TrendHover.value(stop.x)], [this.options.yLabel ?? this.options.y, TrendHover.value(stop.y)]]
-		}));
-	}
-};
-export { ConnectedScatterTime };

package/dist/charts/linesareas/SmallMultipleLines.js

@@ -1,153 +0,0 @@
-import { Chart2D } from "../../core/Chart2D.js";
-import { ChartFamily, CurveKind, DataShape, Dimension, LegendPosition } from "../../core/enums.js";
-import { Scales } from "../../core/Scales.js";
-import { SampleData } from "../../data/SampleData.js";
-import { FacetScale, LineAggregate } from "./LineEnums.js";
-import { TrendHover } from "./TrendHover.js";
-import { TrendLabels } from "./TrendLabels.js";
-import { TrendTable } from "./TrendTable.js";
-import { area, extent, line, scaleLinear, select, ticks, utcFormat } from "d3";
-// src/charts/linesareas/SmallMultipleLines.ts
-var HEAD = 16;
-var GAP_X = 18;
-var AXIS = 16;
-var YAXIS = 26;
-var shortDate = utcFormat("%b %-d");
-/** One small chart per series on shared axes. The fix for spaghetti: use it whenever a multi-line chart has more than about six lines. */
-var SmallMultipleLines = class SmallMultipleLines extends Chart2D {
-	static meta = {
-		id: "small-multiple-lines",
-		name: "Small multiple lines",
-		family: ChartFamily.Trend,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Splits series into a grid of small line charts on shared scales, comparing many series without tangling them.",
-		tags: [
-			"trellis",
-			"facets",
-			"lattice",
-			"panel"
-		],
-		sample: (seed) => SampleData.timeSeries(seed, 40, 6),
-		variants: {
-			columns: [
-				3,
-				2,
-				1
-			],
-			yScale: [FacetScale.Shared, FacetScale.Free],
-			context: [true, false],
-			fill: [false, true],
-			curve: [
-				CurveKind.Monotone,
-				CurveKind.Linear,
-				CurveKind.StepAfter
-			]
-		},
-		valid: ({ yScale, context }) => yScale === FacetScale.Shared || !context
-	};
-	defaults() {
-		return {
-			x: "date",
-			y: "value",
-			series: "series",
-			aggregate: LineAggregate.Mean,
-			curve: CurveKind.Monotone,
-			yScale: FacetScale.Shared,
-			context: true,
-			fill: false
-		};
-	}
-	get legendPosition() {
-		return LegendPosition.None;
-	}
-	legendItems() {
-		return [];
-	}
-	plotMargin() {
-		return {
-			top: 6,
-			right: 12,
-			bottom: 6,
-			left: 12
-		};
-	}
-	static range(points, zero) {
-		const [lo = 0, hi = 1] = extent(points.flatMap((p) => p.y === null ? [] : zero ? [p.y, 0] : [p.y]));
-		return lo === hi ? [lo - 1, hi + 1] : [lo, hi];
-	}
-	static tick(x) {
-		return x instanceof Date ? shortDate(x) : String(x);
-	}
-	draw(ctx) {
-		const { x, y, series, aggregate, curve, yScale, context, fill } = this.options;
-		const table = new TrendTable(this.options.data, {
-			x,
-			y,
-			series,
-			aggregate
-		});
-		const lines = table.series;
-		const { width, height } = ctx.plot;
-		const auto = Math.max(1, Math.round(Math.sqrt(lines.length * width / (height * 1.6))));
-		const columns = Math.max(1, Math.min(this.options.columns ?? auto, lines.length || 1));
-		const rows = Math.max(1, Math.ceil(lines.length / columns));
-		const cellWidth = (width - GAP_X * (columns - 1)) / columns;
-		const gap = rows > 3 ? 3 : 10;
-		const innerWidth = Math.max(10, cellWidth - YAXIS), innerHeight = Math.max(8, (height - AXIS - gap * (rows - 1)) / rows - HEAD);
-		const px = table.xScale([0, innerWidth]);
-		const shared = SmallMultipleLines.range(lines.flatMap((s) => s.points), fill);
-		const facet = ctx.marks("facets", "g", lines, (s) => s.key).attr("transform", (_, i) => `translate(${i % columns * (cellWidth + GAP_X) + YAXIS},${Math.floor(i / columns) * (innerHeight + HEAD + gap) + HEAD})`);
-		const chart = this;
-		facet.each(function(s, i) {
-			const group = select(this);
-			const domain = yScale === FacetScale.Shared ? shared : SmallMultipleLines.range(s.points, fill);
-			const py = scaleLinear(domain, [innerHeight, 0]).nice();
-			const ownColumn = i % columns === 0 || yScale === FacetScale.Free, bottom = i + columns >= lines.length;
-			chart.frame(ctx, group, s, py, innerWidth, innerHeight, ownColumn, bottom ? [table.xs[0], table.xs.at(-1)].flatMap((p) => p ?? []) : []);
-			const known = (p) => p.y !== null;
-			const path = line().defined(known).x((p) => px(p.x)).y((p) => py(p.y)).curve(Scales.curve(curve));
-			const ghosts = ctx.marks("ghosts", "path", context ? lines.filter((other) => other !== s) : [], (o) => o.key, group).attr("fill", "none").attr("stroke", ctx.theme.grid).attr("stroke-width", 1.5);
-			ctx.set(ghosts, { d: (o) => path(o.points) ?? "" });
-			const color = ctx.palette.color(s.key);
-			const base = py(Math.max(py.domain()[0], 0));
-			const under = area().defined(known).x((p) => px(p.x)).y0(base).y1((p) => py(p.y)).curve(Scales.curve(curve));
-			const flat = area().defined(known).x((p) => px(p.x)).y(base).curve(Scales.curve(curve));
-			ctx.set(ctx.marks("fill", "path", fill ? [s] : [], void 0, group).attr("fill", color).attr("fill-opacity", .22), { d: under(s.points) ?? "" }, { d: flat(s.points) ?? "" });
-			const stroke = ctx.marks("line", "path", [s], void 0, group).attr("fill", "none").attr("stroke", color).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
-			stroke.filter(function() {
-				return !this.getAttribute("d");
-			}).attr("d", path(s.points) ?? "");
-			ctx.drawOn(stroke);
-			ctx.set(stroke, { d: path(s.points) ?? "" });
-			const last = s.points.filter(known).at(-1);
-			const end = ctx.marks("end", "circle", last ? [last] : [], void 0, group).attr("fill", color).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
-			ctx.set(end, {
-				cx: (p) => px(p.x),
-				cy: (p) => py(p.y),
-				r: 5
-			}, {
-				cx: (p) => px(p.x),
-				cy: (p) => py(p.y),
-				r: 0
-			});
-			TrendHover.attach(ctx, TrendHover.slices([s], {
-				place: (p) => [px(p.x), py(p.y)],
-				color: () => color
-			}), innerWidth, innerHeight, group);
-		});
-	}
-	frame(ctx, group, s, py, width, height, showY, xTicks) {
-		const [lo, hi] = py.domain();
-		const room = Math.max(1, Math.floor(height / 14));
-		const candidates = ticks(lo, hi, Math.min(4, room));
-		const levels = candidates.filter((_, n) => (candidates.length - 1 - n) % Math.ceil(candidates.length / room) === 0);
-		ctx.marks("grid", "line", levels, (v) => v, group).attr("stroke", ctx.theme.grid).attr("x1", 0).attr("x2", width).attr("y1", py).attr("y2", py);
-		ctx.text(ctx.marks("y-ticks", "text", showY ? levels : [], (v) => v, group), 10).attr("x", -4).attr("y", py).attr("dy", ".32em").attr("text-anchor", "end").text((v) => Scales.format(v, Math.max(Math.abs(lo), Math.abs(hi))));
-		ctx.marks("axis", "line", [0], void 0, group).attr("stroke", ctx.theme.axis).attr("x1", 0).attr("x2", width).attr("y1", height).attr("y2", height);
-		const dated = width >= 80 ? xTicks : xTicks.slice(0, 1);
-		ctx.text(ctx.marks("x-ticks", "text", dated, (p) => p.order, group), 10).attr("x", (_, i) => i ? width : 0).attr("y", height + 12).attr("text-anchor", (_, i) => i ? "end" : "start").text((p) => SmallMultipleLines.tick(p.x));
-		ctx.text(ctx.marks("head", "text", [s.key], void 0, group), 11, "ink").attr("x", 0).attr("y", -5).attr("font-weight", 600).text((key) => TrendLabels.fit(key, width));
-	}
-};
-export { SmallMultipleLines };

package/dist/charts/mathematical/ParametricSurface3D.js

@@ -1,234 +0,0 @@
-import { Chart3D } from "../../core/Chart3D.js";
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { MathNumerics } from "./MathNumerics.js";
-import { BufferGeometry, Color, DoubleSide, Float32BufferAttribute, InstancedMesh, LineBasicMaterial, LineSegments, Mesh, MeshStandardMaterial, Object3D, SphereGeometry } from "three";
-// src/charts/mathematical/ParametricSurface3D.ts
-var SurfaceForm = /* @__PURE__ */ function(SurfaceForm) {
-	SurfaceForm["Torus"] = "torus";
-	SurfaceForm["Mobius"] = "mobius";
-	SurfaceForm["Klein"] = "klein";
-	SurfaceForm["Seashell"] = "seashell";
-	SurfaceForm["Enneper"] = "enneper";
-	SurfaceForm["Helicoid"] = "helicoid";
-	SurfaceForm["Dini"] = "dini";
-	SurfaceForm["Boy"] = "boy";
-	return SurfaceForm;
-}({});
-var SurfaceRender = /* @__PURE__ */ function(SurfaceRender) {
-	SurfaceRender["Solid"] = "solid";
-	SurfaceRender["Mesh"] = "mesh";
-	SurfaceRender["Dots"] = "dots";
-	return SurfaceRender;
-}({});
-var TAU = Math.PI * 2;
-var U = 150;
-var V = 60;
-function named(form, a, b) {
-	const { sin, cos, tan, log, exp } = Math;
-	switch (form) {
-		case "mobius": return {
-			u: [0, TAU],
-			v: [-1, 1],
-			fn: (u, v) => [
-				(1 + v / 2 * cos(u / 2)) * cos(u),
-				(1 + v / 2 * cos(u / 2)) * sin(u),
-				v / 2 * sin(u / 2)
-			]
-		};
-		case "klein": return {
-			u: [0, TAU],
-			v: [0, TAU],
-			fn: (u, v) => {
-				const r = 2 + cos(u / 2) * sin(v) - sin(u / 2) * sin(2 * v);
-				return [
-					r * cos(u),
-					r * sin(u),
-					sin(u / 2) * sin(v) + cos(u / 2) * sin(2 * v)
-				];
-			}
-		};
-		case "seashell": return {
-			u: [0, 3 * TAU],
-			v: [0, TAU],
-			fn: (u, v) => {
-				const g = exp(u / 7), r = g * (1 + .55 * cos(v));
-				return [
-					r * cos(u),
-					r * sin(u),
-					g * (.55 * sin(v)) - g * 1.6
-				];
-			}
-		};
-		case "enneper": return {
-			u: [-1.6, 1.6],
-			v: [-1.6, 1.6],
-			fn: (u, v) => [
-				u - u ** 3 / 3 + u * v * v,
-				v - v ** 3 / 3 + v * u * u,
-				u * u - v * v
-			]
-		};
-		case "helicoid": return {
-			u: [-TAU, TAU],
-			v: [-1.6, 1.6],
-			fn: (u, v) => [
-				v * cos(u * b),
-				v * sin(u * b),
-				u / 2.4
-			]
-		};
-		case "dini": return {
-			u: [0, 2.5 * TAU],
-			v: [.08, 2],
-			fn: (u, v) => [
-				cos(u) * sin(v),
-				sin(u) * sin(v),
-				cos(v) + log(tan(v / 2)) + .18 * u
-			]
-		};
-		case "boy": return {
-			u: [0, Math.PI],
-			v: [0, Math.PI],
-			fn: (u, v) => {
-				const c = cos(u), s = sin(u), cv = cos(v), q = 2 ** .5, d = 2 - q * sin(3 * u) * sin(2 * v);
-				return [
-					(q * cv * cv * cos(2 * u) + c * sin(2 * v)) / d,
-					(q * cv * cv * sin(2 * u) - s * sin(2 * v)) / d,
-					3 * cv * cv / d
-				];
-			}
-		};
-		default: return {
-			u: [0, TAU],
-			v: [0, TAU],
-			fn: (u, v) => [
-				(a + b * cos(v)) * cos(u),
-				(a + b * cos(v)) * sin(u),
-				b * sin(v)
-			]
-		};
-	}
-}
-/** Surfaces given by two parameters, including one-sided and self-crossing forms that no height map can draw. */
-var ParametricSurface3D = class extends Chart3D {
-	static meta = {
-		id: "parametric-surface-3d",
-		name: "Parametric surface",
-		family: ChartFamily.Mathematical,
-		dimension: Dimension.Three,
-		shape: DataShape.Function,
-		description: "Renders a surface in (u, v) as a solid, a mesh or a point cloud, from named forms such as the Möbius strip and Klein bottle.",
-		tags: [
-			"mobius",
-			"klein bottle",
-			"torus",
-			"minimal surface",
-			"topology"
-		],
-		sample: (seed) => SampleData.categories(seed, 1, 1).map((row) => ({
-			name: String(row.category),
-			a: 2,
-			b: .6 + +row.value % 5 * .08
-		})),
-		variants: {
-			form: Object.values(SurfaceForm),
-			render: Object.values(SurfaceRender),
-			sweep: [1, .7]
-		}
-	};
-	defaults() {
-		return {
-			form: "torus",
-			render: "solid",
-			sweep: 1,
-			azimuth: 35,
-			elevation: 28,
-			distance: 3.9
-		};
-	}
-	grid(spec) {
-		const { form, sweep } = this.options;
-		const base = named(form, spec.a ?? 2, spec.b ?? .7);
-		const fn = spec.fn ?? base.fn, u = spec.u ?? base.u, v = spec.v ?? base.v;
-		const us = MathNumerics.linspace(u[0], u[0] + (u[1] - u[0]) * sweep, U), vs = MathNumerics.linspace(v[0], v[1], V);
-		return us.map((a) => vs.map((b) => fn(a, b).map((c) => Number.isFinite(c) ? c : 0)));
-	}
-	build(ctx) {
-		const { render, data } = this.options;
-		const spec = data[0];
-		if (!spec) return;
-		const grid = this.grid(spec);
-		const flat = grid.flat();
-		const axis = (k) => {
-			const values = flat.map((p) => p[k]);
-			return [Math.min(...values), Math.max(...values)];
-		};
-		const [a0, a1] = axis(0), [b0, b1] = axis(1), [c0, c1] = axis(2);
-		const unit = 1.9 / Math.max(a1 - a0, b1 - b0, c1 - c0, 1e-6);
-		const positions = (p) => [
-			(p[0] - (a0 + a1) / 2) * unit,
-			(p[2] - (c0 + c1) / 2) * unit,
-			(p[1] - (b0 + b1) / 2) * unit
-		];
-		const tone = (i) => new Color(ctx.palette.sequential(.25 + .75 * i / 149)).toArray();
-		const vertices = grid.flatMap((line) => line.flatMap(positions));
-		const colors = grid.flatMap((line, i) => line.flatMap(() => tone(i)));
-		const tag = () => ({
-			title: spec.name,
-			rows: [["Vertices", 9e3]]
-		});
-		if (render === "dots") {
-			const picked = flat.filter((_, i) => i % 3 === 0);
-			const cloud = new InstancedMesh(new SphereGeometry(.014, 6, 5), new MeshStandardMaterial({ roughness: .5 }), picked.length);
-			const dummy = new Object3D();
-			picked.forEach((p, i) => {
-				dummy.position.set(...positions(p));
-				dummy.updateMatrix();
-				cloud.setMatrixAt(i, dummy.matrix);
-				cloud.setColorAt(i, new Color(...tone(Math.floor(i * 3 / V))));
-			});
-			cloud.castShadow = true;
-			ctx.reveal((progress) => {
-				cloud.count = Math.max(1, Math.floor(picked.length * progress));
-			}, 1.6);
-			ctx.root.add(cloud);
-			ctx.pick(cloud, tag);
-			return;
-		}
-		const geometry = new BufferGeometry();
-		geometry.setAttribute("position", new Float32BufferAttribute(vertices, 3));
-		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
-		if (render === "mesh") {
-			const pairs = [];
-			for (let i = 0; i < U; i++) for (let j = 0; j < V; j++) {
-				const at = i * V + j;
-				if (j % 4 === 0 && i < 149) pairs.push(at, at + V);
-				if (i % 6 === 0 && j < 59) pairs.push(at, at + 1);
-			}
-			geometry.setIndex(pairs);
-			const lines = new LineSegments(geometry, new LineBasicMaterial({ vertexColors: true }));
-			ctx.reveal((progress) => geometry.setDrawRange(0, Math.floor(pairs.length * progress)), 1.6);
-			ctx.root.add(lines);
-			return;
-		}
-		const faces = [];
-		for (let i = 0; i < 149; i++) for (let j = 0; j < 59; j++) {
-			const p = i * V + j;
-			faces.push(p, p + V, p + 1, p + 1, p + V, p + V + 1);
-		}
-		geometry.setIndex(faces);
-		geometry.computeVertexNormals();
-		const mesh = new Mesh(geometry, new MeshStandardMaterial({
-			vertexColors: true,
-			side: DoubleSide,
-			roughness: .48,
-			metalness: .05
-		}));
-		mesh.castShadow = mesh.receiveShadow = true;
-		ctx.reveal((progress) => geometry.setDrawRange(0, Math.floor(faces.length * progress)), 1.4);
-		ctx.root.add(mesh);
-		ctx.pick(mesh, tag);
-	}
-};
-export { ParametricSurface3D, SurfaceForm, SurfaceRender };