@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/earthscience/Hydrograph.js

@@ -0,0 +1,442 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Draft } from "../scientific/Draft.js";
+import { BaseflowMethod, BaseflowSeparation } from "./BaseflowSeparation.js";
+import { EarthSample } from "./EarthSample.js";
+import { area, axisRight, line, max, median, min, scaleLinear, scaleLog, scaleTime, sum, timeFormat } from "d3";
+// src/charts/earthscience/Hydrograph.ts
+/** Share of the plot height the hyetograph may reach down into. */
+var RAIN_BAND = .3;
+/** Highest share of the discharge axis the peak may reach, which keeps it clear of the rain. */
+var HEADROOM = .64;
+var stamp = timeFormat("%b %-d, %H:%M");
+var clock = timeFormat("%H:%M");
+var day = timeFormat("%b %-d");
+var fixed = (value) => value.toLocaleString("en", { maximumFractionDigits: value < 10 ? 2 : 1 });
+/** Storm hydrograph: discharge against time under a hanging hyetograph, with baseflow separated from direct runoff. */
+var Hydrograph = class extends CartesianChart {
+	static meta = {
+		id: "hydrograph",
+		name: "Storm hydrograph",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots river discharge over time beneath rainfall bars hanging from the top, separating baseflow from direct runoff.",
+		tags: [
+			"hydrology",
+			"hyetograph",
+			"baseflow",
+			"discharge",
+			"rainfall-runoff",
+			"phi index"
+		],
+		sample: (seed) => EarthSample.hydrograph(seed),
+		variants: {
+			baseflow: Object.values(BaseflowMethod),
+			scale: [ScaleKind.Linear, ScaleKind.Log],
+			rainStep: [
+				1,
+				3,
+				6
+			],
+			losses: [false, true],
+			annotate: [false, true]
+		},
+		valid: (values) => !(values.losses && values.baseflow === BaseflowMethod.None)
+	};
+	#rainLegend = [];
+	defaults() {
+		return {
+			time: "time",
+			flow: "flow",
+			rain: "rain",
+			baseflow: BaseflowMethod.None,
+			scale: ScaleKind.Linear,
+			rainStep: 1,
+			losses: false,
+			annotate: false,
+			area: EarthSample.area,
+			bfiMax: .8,
+			yLabel: "Discharge (m³/s)"
+		};
+	}
+	plotMargin() {
+		return {
+			...super.plotMargin(),
+			right: 54
+		};
+	}
+	legendItems() {
+		return [...this.palette.items(), ...this.#rainLegend];
+	}
+	/** Midnights name the day and other ticks the hour. Log paper keeps its minor grid, but only 1, 2 and 5 carry a label. */
+	tickFormat(scale) {
+		const format = super.tickFormat(scale);
+		if (scale.domain?.()[0] instanceof Date) return (value) => {
+			const date = value;
+			return date.getHours() || date.getMinutes() ? clock(date) : day(date);
+		};
+		if (!format || this.options.scale !== ScaleKind.Log) return format;
+		return (value) => /^[125]e/.test((+value).toExponential()) ? format(value) : "";
+	}
+	read() {
+		const { data, time, flow, rain, baseflow, area: basin, recession, bfiMax } = this.options;
+		let dated = false;
+		const seen = /* @__PURE__ */ new Map();
+		for (const row of data ?? []) {
+			const raw = row[time];
+			if (raw instanceof Date || typeof raw === "string") dated = true;
+			const t = raw instanceof Date ? raw.getTime() : typeof raw === "string" ? Date.parse(raw) : Draft.number(raw);
+			if (t === null || !Number.isFinite(t) || seen.has(t)) continue;
+			seen.set(t, {
+				t,
+				q: Draft.number(row[flow]),
+				rain: Math.max(0, Draft.number(row[rain]) ?? 0)
+			});
+		}
+		const unit = dated ? 36e5 : 1;
+		let held = null;
+		const records = [...seen.values()].sort((a, b) => a.t - b.t).flatMap((record) => {
+			held = record.q ?? held;
+			return held === null ? [] : [{
+				...record,
+				q: Math.max(0, held)
+			}];
+		});
+		const hours = records.map((record) => (record.t - records[0].t) / unit);
+		const q = records.map((record) => record.q);
+		const step = median(hours.slice(1).map((hour, i) => hour - hours[i])) ?? 1;
+		const events = BaseflowSeparation.events(q, hours, basin);
+		const base = BaseflowSeparation.separate(baseflow, q, hours, basin, {
+			recession,
+			bfiMax
+		});
+		const steps = records.map((record, i) => ({
+			t: record.t,
+			hours: hours[i],
+			q: record.q,
+			rain: record.rain,
+			base: base[i]
+		}));
+		const total = sum(q);
+		return {
+			steps,
+			dated,
+			step,
+			unit,
+			events,
+			runoff: sum(steps, (d) => d.q - d.base) * step * 3.6 / basin,
+			bfi: total ? sum(base) / total : 0
+		};
+	}
+	bins({ steps, step, unit }) {
+		const size = Math.max(1, Math.round(this.options.rainStep));
+		return Array.from({ length: Math.ceil(steps.length / size) }, (_, k) => {
+			const slice = steps.slice(k * size, (k + 1) * size);
+			return {
+				key: k,
+				start: slice[0].t,
+				stop: steps[(k + 1) * size]?.t ?? slice.at(-1).t + step * unit,
+				depth: sum(slice, (d) => d.rain)
+			};
+		});
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot;
+		const reading = this.read();
+		const { steps, step, unit, dated, runoff } = reading;
+		const start = steps[0]?.t ?? 0, stop = (steps.at(-1)?.t ?? 0) + step * unit;
+		const x = dated ? scaleTime([new Date(start), new Date(stop)], [0, width]) : scaleLinear([start, stop], [0, width]);
+		const place = (t) => dated ? x(new Date(t)) : x(t);
+		const peak = max(steps, (d) => d.q) || 1;
+		const log = this.options.scale === ScaleKind.Log;
+		const decade = 10 ** Math.floor(Math.log10(min(steps, (d) => d.q > 0 ? d.q : void 0) ?? peak));
+		const y = log ? scaleLog([decade, decade * (peak / decade) ** (1 / HEADROOM)], [height, 0]) : scaleLinear([0, peak / HEADROOM], [height, 0]).nice();
+		const floor = y.domain()[0];
+		const bins = this.bins(reading);
+		return {
+			x,
+			y,
+			place,
+			level: (q) => y(Math.max(q, floor)),
+			depth: scaleLinear([0, max(bins, (bin) => bin.depth) || 1], [0, height * RAIN_BAND]).nice(3),
+			reading,
+			bins,
+			phi: this.options.losses && this.options.baseflow !== BaseflowMethod.None ? BaseflowSeparation.phiIndex(bins.map((bin) => bin.depth), runoff) : 0
+		};
+	}
+	plotMarks(ctx, axes) {
+		const { baseflow, annotate } = this.options;
+		const separated = baseflow !== BaseflowMethod.None && axes.reading.steps.length > 0;
+		const hasRain = axes.bins.some((bin) => bin.depth > 0);
+		const stream = ctx.palette.color("Streamflow");
+		this.drawVolumes(ctx, axes, separated);
+		this.drawRainAxis(ctx, axes, hasRain);
+		this.drawHits(ctx, axes, separated);
+		this.drawRain(ctx, axes);
+		const flow = line().x((d) => axes.place(d.t)).y((d) => axes.level(d.q));
+		const under = line().x((d) => axes.place(d.t)).y((d) => axes.level(d.base));
+		const parts = axes.reading.steps.length > 1 ? [{
+			key: "base",
+			d: separated ? under(axes.reading.steps) : null
+		}, {
+			key: "flow",
+			d: flow(axes.reading.steps)
+		}].filter((part) => part.d) : [];
+		const lines = ctx.marks("hydro-lines", "path", parts, (part) => part.key).attr("fill", "none").attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke-linecap", "round").attr("stroke", (part) => part.key === "flow" ? stream : ctx.palette.color("Baseflow")).style("pointer-events", "none");
+		ctx.set(lines, { d: (part) => part.d }, { d: (part) => part.d });
+		ctx.drawOn(lines);
+		this.drawAnnotations(ctx, axes, annotate ? this.main(axes.reading) : null);
+		this.#rainLegend = !hasRain ? [] : axes.phi ? [{
+			key: "excess",
+			label: "Excess rainfall",
+			color: ctx.palette.sequential(.75)
+		}, {
+			key: "losses",
+			label: "Losses",
+			color: ctx.theme.inkMuted
+		}] : [{
+			key: "rain",
+			label: "Rainfall",
+			color: ctx.palette.sequential(.75)
+		}];
+	}
+	drawVolumes(ctx, { place, level, reading }, separated) {
+		const { height } = ctx.plot;
+		const shapes = separated && reading.steps.length > 1 ? [{
+			key: "Direct runoff",
+			low: (d) => level(d.base),
+			high: (d) => level(d.q),
+			rest: (d) => level(d.base)
+		}, {
+			key: "Baseflow",
+			low: () => height,
+			high: (d) => level(d.base),
+			rest: () => height
+		}] : [];
+		const outline = (shape, top) => area().x((d) => place(d.t)).y0(shape.low).y1(top)(reading.steps) ?? "";
+		const fills = ctx.marks("hydro-volumes", "path", shapes, (shape) => shape.key).attr("fill", (shape) => ctx.palette.color(shape.key)).attr("fill-opacity", .2).style("pointer-events", "none");
+		ctx.set(fills, { d: (shape) => outline(shape, shape.high) }, { d: (shape) => outline(shape, shape.rest) });
+	}
+	/** Hours one hyetograph bar spans, which is the time base of its depth and of phi. */
+	barHours({ step }) {
+		return +(step * Math.max(1, Math.round(this.options.rainStep))).toFixed(2);
+	}
+	drawRainAxis(ctx, { depth, reading }, shown) {
+		const { width } = ctx.plot;
+		const axis = axisRight(depth).tickValues(shown ? depth.ticks(2) : []).tickSize(0).tickFormat((value) => fixed(+value));
+		Draft.axis(ctx, "axis-rain", axis, `translate(${width},0)`, false);
+		Draft.rules(ctx, "rain-datum", shown ? [{
+			x1: 0,
+			y1: 0,
+			x2: width,
+			y2: 0
+		}] : [], { stroke: ctx.theme.axis });
+		const title = {
+			text: `Rainfall (mm/${this.barHours(reading)} h)`,
+			x: width + 42,
+			y: 0,
+			anchor: "start",
+			rotate: 90
+		};
+		Draft.captions(ctx, "rain-title", shown ? [title] : []);
+	}
+	drawHits(ctx, { place, reading }, separated) {
+		const { width, height } = ctx.plot;
+		const { steps, dated } = reading;
+		const edge = (i) => i < 0 ? 0 : i >= steps.length - 1 ? width : (place(steps[i].t) + place(steps[i + 1].t)) / 2;
+		const cells = ctx.marks("hydro-hits", "rect", steps, (d) => d.t).attr("fill", "transparent").attr("x", (_, i) => edge(i - 1)).attr("y", 0).attr("width", (_, i) => Math.max(0, edge(i) - edge(i - 1))).attr("height", height);
+		ctx.hover(cells, (d) => ({
+			title: dated ? stamp(new Date(d.t)) : `Hour ${fixed(d.hours)}`,
+			color: ctx.palette.color("Streamflow"),
+			rows: [
+				["Discharge", `${fixed(d.q)} m³/s`],
+				...separated ? [["Baseflow", `${fixed(d.base)} m³/s`]] : [],
+				["Rainfall", `${fixed(d.rain)} mm`]
+			]
+		}));
+	}
+	drawRain(ctx, { place, depth, bins, phi, reading }) {
+		const peak = depth.domain()[1];
+		const parts = bins.filter((bin) => bin.depth > 0).flatMap((bin) => {
+			if (!phi) return [{
+				key: `${bin.key}`,
+				bin,
+				from: 0,
+				to: bin.depth,
+				loss: false,
+				end: true
+			}];
+			const held = Math.min(phi, bin.depth);
+			return [{
+				key: `${bin.key}/loss`,
+				bin,
+				from: 0,
+				to: held,
+				loss: true,
+				end: bin.depth <= phi
+			}, ...bin.depth > phi ? [{
+				key: `${bin.key}/excess`,
+				bin,
+				from: phi,
+				to: bin.depth,
+				loss: false,
+				end: true
+			}] : []];
+		});
+		const box = (part) => {
+			const left = place(part.bin.start), span = place(part.bin.stop) - left;
+			const gap = span >= 4 ? 2 : span >= 2.5 ? 1 : 0;
+			return {
+				x: left + gap / 2,
+				w: Math.max(1, span - gap)
+			};
+		};
+		const shape = (part, to) => {
+			const { x, w } = box(part);
+			const top = depth(part.from) + (part.from ? Math.min(2, depth(to) - depth(part.from)) : 0), bottom = depth(to);
+			const r = part.end ? Math.min(4, w / 2, bottom - top) : 0;
+			return `M${x},${top}H${x + w}V${bottom - r}Q${x + w},${bottom} ${x + w - r},${bottom}H${x + r}Q${x},${bottom} ${x},${bottom - r}Z`;
+		};
+		const bars = ctx.marks("hydro-rain", "path", parts, (part) => part.key).attr("fill", (part) => part.loss ? ctx.theme.inkMuted : ctx.palette.sequential(.4 + .6 * part.bin.depth / peak)).attr("fill-opacity", (part) => part.loss ? .55 : 1);
+		ctx.set(bars, { d: (part) => shape(part, part.to) }, { d: (part) => shape(part, part.from) }, 3);
+		ctx.hover(bars, (part) => ({
+			title: part.loss ? "Losses" : phi ? "Excess rainfall" : "Rainfall",
+			rows: [["Depth", `${fixed(part.to - part.from)} mm`], ["Bar total", `${fixed(part.bin.depth)} mm`]]
+		}));
+		const y = depth(phi);
+		Draft.rules(ctx, "hydro-phi", phi ? [{
+			x1: 0,
+			y1: y,
+			x2: ctx.plot.width,
+			y2: y
+		}] : [], {
+			stroke: ctx.theme.inkSecondary,
+			dash: "4 3"
+		});
+		Draft.captions(ctx, "hydro-phi-label", phi ? [{
+			text: `φ ${fixed(phi)} mm/${this.barHours(reading)} h`,
+			x: ctx.plot.width - 4,
+			y: y + 13,
+			anchor: "end",
+			tone: "ink"
+		}] : []).attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3);
+	}
+	/** The largest storm, with the centroid of the rain burst that fed its peak. */
+	main({ steps, step, events }) {
+		if (!events.length) return null;
+		const event = events.reduce((best, next) => steps[next.peak].q > steps[best.peak].q ? next : best);
+		let wettest = event.peak;
+		while (wettest >= 0 && !steps[wettest].rain) wettest--;
+		if (wettest < 0) return {
+			event,
+			centroid: null
+		};
+		let first = wettest;
+		for (let i = wettest - 1, dry = 0; i >= 0 && dry * step <= 6; i--) if (steps[i].rain > 0) {
+			first = i;
+			dry = 0;
+		} else dry++;
+		const burst = steps.slice(first, wettest + 1);
+		return {
+			event,
+			centroid: sum(burst, (d) => d.rain * (d.hours + step / 2)) / sum(burst, (d) => d.rain)
+		};
+	}
+	drawAnnotations(ctx, { place, level, reading, depth, bins }, main) {
+		const { steps, unit, events, runoff, bfi } = reading;
+		const graphical = [
+			BaseflowMethod.ConstantDischarge,
+			BaseflowMethod.ConstantSlope,
+			BaseflowMethod.Concave
+		].includes(this.options.baseflow);
+		const tops = main ? [main.event.peak] : [];
+		const crest = main ? steps[main.event.peak] : null;
+		const px = crest ? place(crest.t) : 0, py = crest ? level(crest.q) : 0;
+		const lag = crest && main?.centroid != null ? crest.hours - main.centroid : null;
+		const from = lag !== null ? place(crest.t - lag * unit) : px;
+		const shown = lag !== null && lag > 0 ? lag : null;
+		const fed = crest ? crest.t - (lag ?? 0) * unit : 0;
+		const hung = bins.find((bin) => fed >= bin.start && fed < bin.stop)?.depth ?? 0;
+		const span = shown === null ? [] : [{
+			x1: from,
+			y1: py,
+			x2: px,
+			y2: py
+		}, {
+			x1: from,
+			y1: Math.min(depth(hung) + 3, py),
+			x2: from,
+			y2: py
+		}];
+		Draft.rules(ctx, "hydro-lag", span, {
+			stroke: ctx.theme.inkSecondary,
+			dash: "3 3"
+		});
+		const dots = ctx.marks("hydro-peak", "circle", tops, (i) => i).attr("fill", ctx.palette.color("Streamflow")).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: px,
+			cy: py,
+			r: 5
+		}, {
+			cx: px,
+			cy: py,
+			r: 0
+		});
+		ctx.hover(dots, () => ({
+			title: "Peak of the storm",
+			color: ctx.palette.color("Streamflow"),
+			rows: [
+				["Discharge", `${fixed(crest.q)} m³/s`],
+				...shown === null ? [] : [["Lag", `${fixed(shown)} h`]],
+				...this.options.baseflow === BaseflowMethod.None ? [] : [["Direct runoff", `${fixed(runoff)} mm`], ["Baseflow index", fixed(bfi)]]
+			]
+		}));
+		const stops = main && graphical ? events.flatMap((event) => [event.rise, event.end]) : [];
+		const pins = ctx.marks("hydro-stops", "circle", stops, (_, i) => i).attr("fill", ctx.theme.surface).attr("stroke", ctx.palette.color("Streamflow")).attr("stroke-width", 2);
+		ctx.set(pins, {
+			cx: (i) => place(steps[i].t),
+			cy: (i) => level(steps[i].q),
+			r: 4
+		});
+		ctx.hover(pins, (i) => ({
+			title: events.some((event) => event.rise === i) ? "Rise of direct runoff" : "End of direct runoff",
+			rows: [["Discharge", `${fixed(steps[i].q)} m³/s`]]
+		}));
+		const peakText = crest ? `Peak ${fixed(crest.q)} m³/s${shown === null ? "" : `, lag ${fixed(shown)} h`}` : "";
+		const fitsRight = px + 12 + peakText.length * 6.2 <= ctx.plot.width;
+		const notes = !crest ? [] : [fitsRight ? {
+			text: peakText,
+			x: px + 10,
+			y: py + 4,
+			anchor: "start",
+			tone: "ink"
+		} : {
+			text: peakText,
+			x: px - 10,
+			y: py + 4,
+			anchor: "end",
+			tone: "ink"
+		}];
+		Draft.captions(ctx, "hydro-notes", Draft.declutter(notes, ctx.plot.width, ctx.plot.height)).attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3);
+	}
+	table() {
+		const { steps, dated } = this.read();
+		const separated = this.options.baseflow !== BaseflowMethod.None;
+		return {
+			columns: [
+				"time",
+				"flow",
+				"rain",
+				...separated ? ["baseflow"] : []
+			],
+			rows: steps.map((d) => [
+				dated ? new Date(d.t) : d.t,
+				d.q,
+				d.rain,
+				...separated ? [d.base] : []
+			])
+		};
+	}
+};
+export { Hydrograph };

package/dist/charts/earthscience/SimplexContours.js

@@ -0,0 +1,94 @@
+// src/charts/earthscience/SimplexContours.ts
+var DIVISIONS = 40;
+/**
+* Marching triangles on a subdivided simplex. Working on triangles rather than a pixel grid
+* means bands end exactly on the frame, with no staircase along the sloping sides.
+*/
+var SimplexContours = class {
+	#points = [];
+	#values = [];
+	#triangles = [];
+	lowest;
+	highest;
+	constructor(simplex, surface, n = DIVISIONS) {
+		const index = [];
+		for (let i = 0; i <= n; i++) {
+			index[i] = [];
+			for (let j = 0; j <= n - i; j++) {
+				const a = i / n, b = j / n, c = (n - i - j) / n;
+				index[i][j] = this.#points.length;
+				this.#points.push(simplex.at(a, b, c));
+				this.#values.push(surface(a, b, c));
+			}
+		}
+		for (let i = 0; i < n; i++) for (let j = 0; j < n - i; j++) {
+			this.#triangles.push([
+				index[i][j],
+				index[i + 1][j],
+				index[i][j + 1]
+			]);
+			if (i + j < n - 1) this.#triangles.push([
+				index[i + 1][j],
+				index[i + 1][j + 1],
+				index[i][j + 1]
+			]);
+		}
+		this.lowest = Math.min(...this.#values);
+		this.highest = Math.max(...this.#values);
+	}
+	#cross(from, to, level) {
+		const t = (level - this.#values[from]) / (this.#values[to] - this.#values[from]);
+		const p = this.#points[from], q = this.#points[to];
+		return [p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t];
+	}
+	/** Path of everything at or above `level`. Painting levels low to high leaves no seams between bands. */
+	band(level) {
+		let d = "";
+		for (const corners of this.#triangles) {
+			const shape = [];
+			corners.forEach((corner, k) => {
+				const next = corners[(k + 1) % 3];
+				const inside = this.#values[corner] >= level, onward = this.#values[next] >= level;
+				if (inside) shape.push(this.#points[corner]);
+				if (inside !== onward) shape.push(this.#cross(corner, next, level));
+			});
+			if (shape.length > 2) d += `M${shape.map(([x, y]) => `${x.toFixed(1)},${y.toFixed(1)}`).join("L")}Z`;
+		}
+		return d;
+	}
+	/** The isoline at `level`, stitched into chains across triangles. */
+	lines(level) {
+		const places = /* @__PURE__ */ new Map();
+		const links = /* @__PURE__ */ new Map();
+		const link = (from, to) => {
+			const list = links.get(from);
+			if (list) list.push(to);
+			else links.set(from, [to]);
+		};
+		for (const corners of this.#triangles) {
+			const hits = [];
+			corners.forEach((corner, k) => {
+				const next = corners[(k + 1) % 3];
+				if (this.#values[corner] >= level === this.#values[next] >= level) return;
+				const key = `${Math.min(corner, next)}/${Math.max(corner, next)}`;
+				if (!places.has(key)) places.set(key, this.#cross(corner, next, level));
+				hits.push(key);
+			});
+			if (hits.length === 2) {
+				link(hits[0], hits[1]);
+				link(hits[1], hits[0]);
+			}
+		}
+		const visited = /* @__PURE__ */ new Set();
+		const walk = (start) => {
+			const chain = [];
+			for (let at = start; at && !visited.has(at); at = links.get(chain.at(-1)).find((next) => !visited.has(next))) {
+				visited.add(at);
+				chain.push(at);
+			}
+			return chain.map((key) => places.get(key));
+		};
+		return [...[...links.keys()].filter((key) => links.get(key).length === 1), ...links.keys()].flatMap((key) => visited.has(key) ? [] : [walk(key)]).filter((chain) => chain.length > 1);
+	}
+};
+export { SimplexContours };

package/dist/charts/earthscience/SimplexField.js

@@ -0,0 +1,118 @@
+// src/charts/earthscience/SimplexField.ts
+var RISE = Math.sqrt(3) / 2;
+/** Multiplicative replacement of zero parts, so that log-ratios stay finite. */
+var ZERO = .005;
+var planar = ({ a, c }) => [c + a / 2, a * RISE];
+var closed = (a, b, c) => {
+	const [x, y, z] = [
+		Math.max(a, ZERO),
+		Math.max(b, ZERO),
+		Math.max(c, ZERO)
+	], total = x + y + z;
+	return {
+		a: x / total,
+		b: y / total,
+		c: z / total
+	};
+};
+/** Isometric log-ratio coordinates: Euclidean distance here is Aitchison distance on the simplex. */
+var logRatio = (raw) => {
+	const { a, b, c } = closed(raw.a, raw.b, raw.c);
+	return [Math.log(a / b) / Math.SQRT2, Math.log(a * b / (c * c)) / Math.sqrt(6)];
+};
+/** Scalar surfaces over a ternary simplex, from sample density or from sampled values. */
+var SimplexField = class {
+	/** Gaussian kernel density at three quarters of Silverman's bandwidth (σ n^(-1/6) in two dimensions), in the plane or in log-ratio space. */
+	static density(rows, logarithmic) {
+		const project = logarithmic ? logRatio : planar;
+		const points = rows.map(project);
+		const spread = (k) => {
+			const mean = points.reduce((sum, p) => sum + p[k], 0) / (points.length || 1);
+			return points.reduce((sum, p) => sum + (p[k] - mean) ** 2, 0) / (points.length || 1);
+		};
+		const sigma = Math.sqrt((spread(0) + spread(1)) / 2);
+		const h = Math.max(sigma * .75 * (points.length || 1) ** (-1 / 6), logarithmic ? .12 : .02);
+		const scale = -.5 / (h * h);
+		return (a, b, c) => {
+			const [x, y] = project({
+				a,
+				b,
+				c
+			});
+			return points.reduce((sum, p) => sum + Math.exp(((x - p[0]) ** 2 + (y - p[1]) ** 2) * scale), 0);
+		};
+	}
+	/** Shepard interpolation: honours every sample exactly. */
+	static inverseDistance(rows) {
+		const points = rows.flatMap((row) => row.value === null ? [] : [{
+			p: planar(row),
+			value: row.value
+		}]);
+		return (a, _b, c) => {
+			const [x, y] = planar({
+				a,
+				c
+			});
+			let top = 0, bottom = 0;
+			for (const { p, value } of points) {
+				const weight = 1 / ((x - p[0]) ** 2 + (y - p[1]) ** 2 + 1e-6) ** 2;
+				top += weight * value;
+				bottom += weight;
+			}
+			return bottom ? top / bottom : 0;
+		};
+	}
+	/** Scheffé canonical mixture polynomial by least squares: quadratic, or special cubic with the three-way blend. */
+	static scheffe(rows, cubic) {
+		const basis = (a, b, c) => cubic ? [
+			a,
+			b,
+			c,
+			a * b,
+			a * c,
+			b * c,
+			a * b * c
+		] : [
+			a,
+			b,
+			c,
+			a * b,
+			a * c,
+			b * c
+		];
+		const size = cubic ? 7 : 6;
+		const normal = Array.from({ length: size }, () => new Array(size + 1).fill(0));
+		for (const row of rows) {
+			if (row.value === null) continue;
+			const terms = basis(row.a, row.b, row.c);
+			for (let i = 0; i < size; i++) {
+				for (let j = 0; j < size; j++) normal[i][j] += terms[i] * terms[j];
+				normal[i][size] += terms[i] * row.value;
+			}
+		}
+		for (let i = 0; i < size; i++) normal[i][i] += 1e-8;
+		const beta = solve(normal);
+		return (a, b, c) => basis(a, b, c).reduce((sum, term, i) => sum + term * beta[i], 0);
+	}
+};
+/** Gaussian elimination with partial pivoting, on an augmented matrix. */
+function solve(matrix) {
+	const n = matrix.length;
+	for (let col = 0; col < n; col++) {
+		let pivot = col;
+		for (let row = col + 1; row < n; row++) if (Math.abs(matrix[row][col]) > Math.abs(matrix[pivot][col])) pivot = row;
+		[matrix[col], matrix[pivot]] = [matrix[pivot], matrix[col]];
+		for (let row = col + 1; row < n; row++) {
+			const factor = matrix[row][col] / matrix[col][col];
+			for (let k = col; k <= n; k++) matrix[row][k] -= factor * matrix[col][k];
+		}
+	}
+	const beta = new Array(n).fill(0);
+	for (let row = n - 1; row >= 0; row--) {
+		let rest = matrix[row][n];
+		for (let k = row + 1; k < n; k++) rest -= matrix[row][k] * beta[k];
+		beta[row] = rest / matrix[row][row];
+	}
+	return beta;
+}
+export { SimplexField };