@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/earthscience/HovmollerDiagram.js

@@ -0,0 +1,477 @@
+import { ChartFamily, ColorScale, DataShape, Dimension } from "../../core/enums.js";
+import { ContourLabels } from "../density/ContourLabels.js";
+import { FieldInterpolation } from "../density/DensityEnums.js";
+import { FieldChart } from "../density/FieldChart.js";
+import { FieldContours } from "../density/FieldContours.js";
+import { Draft } from "../scientific/Draft.js";
+import { HovmollerGuides, HovmollerLongitudes, HovmollerReference, HovmollerSection, HovmollerStyle, HovmollerTimeFlow } from "./HovmollerEnums.js";
+import { HovmollerField } from "./HovmollerField.js";
+import { HovmollerSample } from "./HovmollerSample.js";
+import { HovmollerSpeed } from "./HovmollerSpeed.js";
+import { bisectCenter, bisectRight, extent, pointer, range, scaleLinear, scaleTime, tickStep, ticks, timeFormat } from "d3";
+// src/charts/earthscience/HovmollerDiagram.ts
+var STEPS = [
+	.1,
+	.2,
+	.5,
+	1,
+	2,
+	5,
+	10,
+	15,
+	20,
+	30,
+	45,
+	60,
+	90,
+	120,
+	180
+];
+var MOST_LEVELS = 60;
+var SPOTS = [
+	.86,
+	.14,
+	.68,
+	.32,
+	.5
+];
+var CHIPS = [
+	0,
+	.25,
+	.5,
+	.75,
+	1
+];
+var DAY = 864e5;
+/** Guide labels sit this far above their line, so its dashes do not strike through the text. */
+var LIFT = 6;
+var LINE_FLOOR = .35;
+var stamp = timeFormat("%b %-d");
+var full = timeFormat("%b %-d, %Y");
+var degrees = (value) => value.toLocaleString("en", { maximumFractionDigits: 1 });
+var percent = (share) => `${Math.round(share * 100)}%`;
+/**
+* Hovmöller diagram (Hovmöller 1949, "The trough-and-ridge diagram", Tellus 1): a field averaged over one space
+* coordinate and drawn as position against time, so moving features appear as slanted bands whose slope is their
+* speed. Rows averaged over latitude are cos φ weighted, global sections get a cyclic column, and negative contours are dashed.
+* Use it to trace propagation: troughs and ridges, Madden-Julian and equatorial waves, or SST and sea level anomalies.
+*/
+var HovmollerDiagram = class HovmollerDiagram extends FieldChart {
+	static meta = {
+		id: "hovmoller-diagram",
+		name: "Hovmöller diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Maps a field against time and longitude or latitude, so travelling waves appear as slanted bands whose slope gives their speed.",
+		tags: [
+			"time-longitude",
+			"trough and ridge",
+			"propagation",
+			"phase speed",
+			"Madden-Julian",
+			"radon transform",
+			"anomaly"
+		],
+		sample: (seed) => HovmollerSample.tropics(seed),
+		variants: {
+			section: Object.values(HovmollerSection),
+			style: Object.values(HovmollerStyle),
+			field: [ColorScale.Diverging, ColorScale.Sequential],
+			reference: Object.values(HovmollerReference),
+			guides: Object.values(HovmollerGuides),
+			timeFlow: Object.values(HovmollerTimeFlow),
+			longitudes: [HovmollerLongitudes.Given, HovmollerLongitudes.Greenwich]
+		},
+		valid: ({ section, field, reference, timeFlow, longitudes }) => field === ColorScale.Diverging === (reference !== HovmollerReference.None) && (section === HovmollerSection.Longitude || timeFlow === HovmollerTimeFlow.Down && longitudes === HovmollerLongitudes.Given)
+	};
+	#cache = null;
+	#probe = null;
+	#position = null;
+	defaults() {
+		return {
+			time: "time",
+			longitude: "longitude",
+			latitude: "latitude",
+			value: "value",
+			section: HovmollerSection.Longitude,
+			style: HovmollerStyle.Filled,
+			field: ColorScale.Diverging,
+			reference: HovmollerReference.TimeMean,
+			guides: HovmollerGuides.Speeds,
+			timeFlow: HovmollerTimeFlow.Down,
+			longitudes: HovmollerLongitudes.Given,
+			levels: 10,
+			labels: false,
+			daysPerUnit: 1
+		};
+	}
+	get liveMotion() {
+		return false;
+	}
+	get along() {
+		return this.options.section === HovmollerSection.Longitude;
+	}
+	get diverging() {
+		return this.options.field === ColorScale.Diverging;
+	}
+	/** Gridding and fitting are slow and a zoom repaints every frame, so the result is kept until its inputs change. */
+	reading() {
+		const { data, time, longitude, latitude, value, section, band, longitudes, reference, field, levels, interval, center, daysPerUnit, guideLatitude } = this.options;
+		const key = JSON.stringify([
+			time,
+			longitude,
+			latitude,
+			value,
+			section,
+			band,
+			longitudes,
+			reference,
+			field,
+			levels,
+			interval,
+			center,
+			daysPerUnit,
+			guideLatitude
+		]);
+		if (this.#cache?.data === data && this.#cache.key === key && !this.liveFrame) return this.#cache.reading;
+		const read = {
+			time,
+			longitude,
+			latitude,
+			value,
+			section,
+			band,
+			longitudes,
+			daysPerUnit
+		};
+		const base = HovmollerField.read(data, read), shown = base.anomaly(reference);
+		const [low = 0, high = 0] = extent(shown.values.filter((v) => !Number.isNaN(v)));
+		const middle = this.diverging ? center ?? (low < 0 && high > 0 ? 0 : (low + high) / 2) : low;
+		const reach = this.diverging ? Math.max(Math.abs(low - middle), Math.abs(high - middle)) : high - low;
+		const reading = {
+			base,
+			field: shown.closed(),
+			levels: this.contourLevels(low, high, middle, reach),
+			low,
+			high,
+			middle,
+			reach
+		};
+		this.#cache = {
+			data,
+			key,
+			reading
+		};
+		return reading;
+	}
+	/** Round levels: mirrored about the middle on a diverging field, so the two signs are drawn alike. */
+	contourLevels(low, high, middle, reach) {
+		const { levels, interval } = this.options;
+		if (!(reach > 0)) return [];
+		const asked = Math.max(1, Math.round(levels));
+		const allowed = interval && interval > 0 && reach / interval <= MOST_LEVELS ? interval : null;
+		if (!this.diverging) return (allowed ? range(Math.ceil(low / allowed) * allowed, high, allowed) : ticks(low, high, asked)).filter((value) => value > low && value < high);
+		const step = allowed ?? tickStep(0, reach, Math.max(1, Math.floor(asked / 2)));
+		const arm = range(step, reach, step);
+		return [
+			...arm.map((value) => middle - value).reverse(),
+			middle,
+			...arm.map((value) => middle + value)
+		].filter((value) => value > low && value < high);
+	}
+	scales(ctx) {
+		this.clearRamp();
+		const { width, height } = ctx.plot;
+		const { field } = this.reading();
+		const moments = field.times, places = field.positions;
+		const wide = field.dated ? DAY : 1;
+		const [from = 0, to = 1] = extent(moments), [start = this.along ? 0 : -90, stop = this.along ? 360 : 90] = extent(places);
+		const span = from === to ? [from - wide, to + wide] : [from, to];
+		const reach = start === stop ? [start - 1, stop + 1] : [start, stop];
+		const time = field.dated ? scaleTime().domain(span) : scaleLinear().domain(span);
+		const position = this.#position = scaleLinear().domain(reach);
+		position.ticks = (count = 6) => {
+			const [a, b] = [...position.domain()].sort((p, q) => p - q);
+			const step = STEPS.find((candidate) => (b - a) / candidate <= count) ?? 180;
+			return range(Math.ceil(a / step) * step, b + step * 1e-6, step);
+		};
+		if (!this.along) {
+			time.range([0, width]);
+			position.range([height, 0]);
+			return {
+				x: time,
+				y: position,
+				position,
+				time
+			};
+		}
+		position.range([0, width]);
+		time.range([height, 0]);
+		if (this.options.timeFlow === HovmollerTimeFlow.Down) time.domain([...time.domain()].reverse());
+		return {
+			x: position,
+			y: time,
+			position,
+			time
+		};
+	}
+	tickFormat(scale) {
+		if (scale === this.#position) return (value) => this.placeName(+value);
+		return super.tickFormat(scale) ?? (this.reading().field.dated ? (value) => stamp(value) : null);
+	}
+	placeName(value) {
+		if (!this.along) return value === 0 ? "Eq" : `${degrees(Math.abs(value))}°${value > 0 ? "N" : "S"}`;
+		const turned = ((value + 180) % 360 + 360) % 360 - 180;
+		return turned === 0 || turned === -180 ? `${degrees(Math.abs(turned))}°` : `${degrees(Math.abs(turned))}°${turned > 0 ? "E" : "W"}`;
+	}
+	momentName(time) {
+		return this.reading().field.dated ? full(new Date(time)) : `${degrees(time)}`;
+	}
+	/** Fractional grid indexes to pixels, keeping stretched grids true. */
+	projector({ position, time }, field) {
+		const across = scaleLinear(range(field.columns), field.positions), down = scaleLinear(range(field.rows), field.times);
+		return (i, j) => this.pixel({
+			position,
+			time
+		}, across(i), down(j));
+	}
+	pixel({ position, time }, place, moment) {
+		const a = position(place), b = time(moment);
+		return this.along ? [a, b] : [b, a];
+	}
+	tone(ctx, { middle, reach, low }, value) {
+		if (!(reach > 0)) return this.diverging ? ctx.palette.diverging(0) : ctx.palette.sequential(.5);
+		return this.diverging ? ctx.palette.diverging((value - middle) / reach) : ctx.palette.sequential((value - low) / reach);
+	}
+	bands(ctx, reading) {
+		const stops = [
+			reading.low,
+			...reading.levels,
+			reading.high
+		];
+		return stops.slice(0, -1).map((from, i) => ({
+			from,
+			to: stops[i + 1],
+			fill: this.tone(ctx, reading, (from + stops[i + 1]) / 2)
+		}));
+	}
+	plotMarks(ctx, axes) {
+		const reading = this.reading(), { field, levels } = reading;
+		const { style, labels } = this.options;
+		const count = field.values.length;
+		const contours = field.columns > 1 && field.rows > 1 && count ? new FieldContours(Array.from(field.values), field.columns, field.rows, this.projector(axes, field), FieldInterpolation.Smooth) : null;
+		const bands = count ? this.bands(ctx, reading) : [];
+		const cells = count > 0 && (style === HovmollerStyle.Cells || !contours);
+		const filled = !!contours && style === HovmollerStyle.Filled;
+		const lines = style === HovmollerStyle.Lines;
+		const shades = cells ? this.cells(axes, field, bands, levels) : [];
+		const areas = filled ? bands.map((band, i) => ({
+			band,
+			d: contours.at(i ? band.from : reading.low - 1 - reading.reach).area
+		})) : [];
+		this.fills(ctx, axes, "hov-bands", areas, reading);
+		this.fills(ctx, axes, "hov-cells", shades, reading);
+		const drawn = (contours ? levels.map((value) => ({
+			value,
+			label: FieldChart.short(value),
+			shape: contours.at(value)
+		})) : []).filter((level) => level.shape.line);
+		const paths = ctx.marks("hov-lines", "path", drawn, (d) => d.value).attr("fill", "none").attr("stroke-linejoin", "round").attr("stroke-linecap", "round").attr("stroke", (d) => lines ? this.lineTone(ctx, reading, d.value) : ctx.theme.ink).attr("stroke-width", lines ? 2 : 1).attr("stroke-opacity", lines ? 1 : .45).attr("stroke-dasharray", (d) => this.diverging && d.value < reading.middle ? "5 3" : null);
+		this.reveal(ctx, paths, { d: (d) => d.shape.line }, 20);
+		if (lines) ctx.hover(paths, (d) => ({
+			rows: [[this.valueName, d.label]],
+			color: this.lineTone(ctx, reading, d.value)
+		}));
+		else paths.style("pointer-events", "none");
+		ContourLabels.draw(ctx, labels ? drawn.map((d) => ({
+			text: d.label,
+			polylines: d.shape.polylines
+		})) : [], "hov-labels");
+		this.drawGuides(ctx, axes, reading);
+		if (count) this.showScale(ctx, reading);
+	}
+	lineTone(ctx, reading, value) {
+		const { middle, reach, low } = reading;
+		if (!(reach > 0)) return ctx.theme.inkSecondary;
+		if (!this.diverging) return ctx.palette.sequential(LINE_FLOOR + .65 * ((value - low) / reach));
+		const t = (value - middle) / reach;
+		return t === 0 ? ctx.theme.inkMuted : ctx.palette.diverging(Math.sign(t) * (LINE_FLOOR + .65 * Math.abs(t)));
+	}
+	get valueName() {
+		return this.options.valueLabel ?? "Value";
+	}
+	showScale(ctx, reading) {
+		const { middle, reach, low } = reading;
+		if (!(reach > 0)) return;
+		const at = (t) => this.diverging ? middle + (2 * t - 1) * reach : low + t * reach;
+		this.showKey(CHIPS.map((t) => ({
+			key: `ramp-${t}`,
+			label: FieldChart.short(at(t)),
+			color: this.tone(ctx, reading, at(t))
+		})));
+	}
+	fills(ctx, axes, name, shapes, reading) {
+		const paths = ctx.marks(name, "path", shapes, (d) => d.band.from).attr("fill", (d) => d.band.fill);
+		this.reveal(ctx, paths, { d: (d) => d.d }, 12);
+		paths.on("pointermove.probe", (event) => {
+			this.#probe = pointer(event, ctx.root.node());
+		}).on("pointerleave.probe", () => {
+			this.#probe = null;
+		});
+		ctx.hover(paths, ({ band }) => this.tooltip(axes, reading, band));
+	}
+	tooltip({ position, time }, { field }, band) {
+		const within = {
+			color: band.fill,
+			rows: [[this.valueName, `${FieldChart.short(band.from)} to ${FieldChart.short(band.to)}`]]
+		};
+		if (!this.#probe) return within;
+		const [px, py] = this.#probe;
+		const place = position.invert(this.along ? px : py), moment = +time.invert(this.along ? py : px);
+		const i = bisectCenter(field.positions, place), j = bisectCenter(field.times, moment);
+		const value = field.values[i + j * field.columns];
+		return {
+			title: this.momentName(field.times[j]),
+			color: band.fill,
+			rows: [[this.along ? "Longitude" : "Latitude", this.placeName(field.positions[i])], [this.valueName, Number.isNaN(value) ? "no data" : FieldChart.short(value)]]
+		};
+	}
+	/** One path per shade, with runs of equal shade merged along the rows of the grid. Gaps stay unpainted. */
+	cells(axes, field, bands, levels) {
+		const { columns, rows, positions, times, values } = field;
+		const edges = (centers, [low, high]) => [
+			low,
+			...centers.slice(1).map((value, i) => (value + centers[i]) / 2),
+			high
+		];
+		const across = edges(positions, positions.length > 1 ? [positions[0], positions.at(-1)] : axes.position.domain());
+		const down = edges(times, times.length > 1 ? [times[0], times.at(-1)] : axes.time.domain().map(Number).sort((a, b) => a - b));
+		const shade = (k) => Number.isNaN(values[k]) ? -1 : bisectRight(levels, values[k]);
+		const paths = bands.map(() => []);
+		for (let j = 0; j < rows; j++) {
+			let i = 0;
+			while (i < columns) {
+				const tone = shade(i + j * columns);
+				let end = i + 1;
+				while (end < columns && shade(end + j * columns) === tone) end++;
+				if (tone >= 0) {
+					const [x0, y0] = this.pixel(axes, across[i], down[j]), [x1, y1] = this.pixel(axes, across[end], down[j + 1]);
+					paths[tone].push(`M${Math.round(x0)} ${Math.round(y0)}H${Math.round(x1)}V${Math.round(y1)}H${Math.round(x0)}Z`);
+				}
+				i = end;
+			}
+		}
+		return bands.map((band, i) => ({
+			band,
+			d: paths[i].join("")
+		})).filter((shape) => shape.d);
+	}
+	/** Stated speeds spread evenly across space at mid-record, or fitted ones laid along the strongest ridge or trough. */
+	guides(reading) {
+		const { base } = reading;
+		const { guides, guideSpeeds, guideLatitude, band } = this.options;
+		if (guides === HovmollerGuides.None || base.columns < 2 || base.rows < 2) return [];
+		const latitude = this.along ? guideLatitude ?? (band ? (band[0] + band[1]) / 2 : 0) : 0;
+		if (guides === HovmollerGuides.Fitted) return reading.fits ??= [1, -1].flatMap((direction) => {
+			const fit = HovmollerSpeed.fit(base, direction, latitude);
+			return fit ? [{
+				key: `fit-${direction}`,
+				rate: fit.rate,
+				anchor: fit.origin,
+				day: 0,
+				speed: fit.speed,
+				share: fit.share
+			}] : [];
+		});
+		const speeds = guideSpeeds ?? (this.along ? [5, -5] : [1.5, -1.5]);
+		const low = base.positions[0], span = base.positions.at(-1) - low, day = base.days.at(-1) / 2;
+		return speeds.filter(Number.isFinite).map((speed, i) => ({
+			key: `speed-${i}`,
+			rate: HovmollerSpeed.degreesPerDay(speed, latitude),
+			day,
+			speed,
+			anchor: low + span * (i + 1) / (speeds.length + 1)
+		}));
+	}
+	guideLines(axes, { base }, guide, width, height) {
+		const stop = base.days.at(-1);
+		const copies = base.cyclic ? Math.ceil(Math.abs(guide.rate) * stop / 360) + 1 : 0;
+		return range(-copies, copies + 1).flatMap((copy) => {
+			const end = (day) => this.pixel(axes, guide.anchor + copy * 360 + guide.rate * (day - guide.day), base.timeAt(day));
+			const ends = HovmollerDiagram.clip(end(0), end(stop), width, height);
+			return ends ? [{
+				guide,
+				ends,
+				d: `M${ends[0].map((v) => v.toFixed(1)).join(",")}L${ends[1].map((v) => v.toFixed(1)).join(",")}`
+			}] : [];
+		});
+	}
+	/** Liang-Barsky clipping of a segment to the plot. */
+	static clip([x0, y0], [x1, y1], width, height) {
+		const dx = x1 - x0, dy = y1 - y0;
+		let enter = 0, leave = 1;
+		for (const [p, q] of [
+			[-dx, x0],
+			[dx, width - x0],
+			[-dy, y0],
+			[dy, height - y0]
+		]) {
+			if (p === 0) {
+				if (q < 0) return null;
+				continue;
+			}
+			const t = q / p;
+			if (p < 0) enter = Math.max(enter, t);
+			else leave = Math.min(leave, t);
+		}
+		if (enter >= leave) return null;
+		return [[x0 + enter * dx, y0 + enter * dy], [x0 + leave * dx, y0 + leave * dy]];
+	}
+	drawGuides(ctx, axes, reading) {
+		const { width, height } = ctx.plot;
+		const lines = this.guides(reading).flatMap((guide) => this.guideLines(axes, reading, guide, width, height));
+		const paths = ctx.marks("hov-guides", "path", lines, (_, i) => i).attr("fill", "none").attr("stroke", ctx.theme.ink).attr("stroke-width", 2).attr("stroke-dasharray", "8 4").attr("stroke-linecap", "round");
+		ctx.set(paths, { d: (d) => d.d }, { d: (d) => d.d });
+		ctx.hover(paths, ({ guide }) => ({
+			title: this.guideName(guide),
+			rows: [["Slope", `${degrees(Math.abs(guide.rate))}°/day`], ...guide.share === void 0 ? [] : [["Variance explained", percent(guide.share)]]]
+		}));
+		const placed = [];
+		for (const key of new Set(lines.map((line) => line.guide.key))) {
+			const longest = lines.filter((line) => line.guide.key === key).reduce((a, b) => Math.hypot(b.ends[1][0] - b.ends[0][0], b.ends[1][1] - b.ends[0][1]) > Math.hypot(a.ends[1][0] - a.ends[0][0], a.ends[1][1] - a.ends[0][1]) ? b : a);
+			const text = this.guideName(longest.guide);
+			const spot = SPOTS.map((t) => ({
+				text,
+				size: 10.5,
+				tone: "ink",
+				x: longest.ends[0][0] + t * (longest.ends[1][0] - longest.ends[0][0]),
+				y: longest.ends[0][1] + t * (longest.ends[1][1] - longest.ends[0][1]) - LIFT
+			})).find((caption) => Draft.declutter([...placed, caption], width, height).length === placed.length + 1);
+			if (spot) placed.push(spot);
+		}
+		Draft.captions(ctx, "hov-guide-labels", placed).attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 4).attr("stroke-linejoin", "round");
+	}
+	guideName({ speed, share }) {
+		const heading = this.along ? speed >= 0 ? "E" : "W" : speed >= 0 ? "N" : "S";
+		return `${share === void 0 ? "" : "fit "}${degrees(Math.abs(speed))} m/s ${heading}`;
+	}
+	table() {
+		const { data } = this.options;
+		if (Array.isArray(data) || !data) return super.table();
+		const { x = [], y = [], z = [] } = data;
+		return {
+			columns: [
+				"time",
+				"position",
+				"value"
+			],
+			rows: y.flatMap((time, t) => x.map((position, p) => [
+				time,
+				position,
+				z[t]?.[p] ?? null
+			]))
+		};
+	}
+};
+export { HovmollerDiagram };

package/dist/charts/earthscience/HovmollerEnums.js

@@ -0,0 +1,42 @@
+// src/charts/earthscience/HovmollerEnums.ts
+/** Which coordinate runs against time: longitude across with time down, or time across with latitude up. */
+var HovmollerSection = /* @__PURE__ */ function(HovmollerSection) {
+	HovmollerSection["Longitude"] = "longitude";
+	HovmollerSection["Latitude"] = "latitude";
+	return HovmollerSection;
+}({});
+/** Filled bands between contours, the grid's own cells under contours, or contours alone. */
+var HovmollerStyle = /* @__PURE__ */ function(HovmollerStyle) {
+	HovmollerStyle["Filled"] = "filled";
+	HovmollerStyle["Cells"] = "cells";
+	HovmollerStyle["Lines"] = "lines";
+	return HovmollerStyle;
+}({});
+/** What is taken away before plotting: each place's mean over time, each moment's mean over space, or nothing. */
+var HovmollerReference = /* @__PURE__ */ function(HovmollerReference) {
+	HovmollerReference["TimeMean"] = "time-mean";
+	HovmollerReference["SpaceMean"] = "space-mean";
+	HovmollerReference["None"] = "none";
+	return HovmollerReference;
+}({});
+/** Lines of constant phase speed: stated speeds, none, or speeds fitted to the field. */
+var HovmollerGuides = /* @__PURE__ */ function(HovmollerGuides) {
+	HovmollerGuides["Speeds"] = "speeds";
+	HovmollerGuides["None"] = "none";
+	HovmollerGuides["Fitted"] = "fitted";
+	return HovmollerGuides;
+}({});
+/** Hovmöller's own layout runs time downward. */
+var HovmollerTimeFlow = /* @__PURE__ */ function(HovmollerTimeFlow) {
+	HovmollerTimeFlow["Down"] = "down";
+	HovmollerTimeFlow["Up"] = "up";
+	return HovmollerTimeFlow;
+}({});
+/** Longitudes as supplied, or wrapped to −180..180 or 0..360. */
+var HovmollerLongitudes = /* @__PURE__ */ function(HovmollerLongitudes) {
+	HovmollerLongitudes["Given"] = "given";
+	HovmollerLongitudes["Greenwich"] = "greenwich";
+	HovmollerLongitudes["Dateline"] = "dateline";
+	return HovmollerLongitudes;
+}({});
+export { HovmollerGuides, HovmollerLongitudes, HovmollerReference, HovmollerSection, HovmollerStyle, HovmollerTimeFlow };

package/dist/charts/earthscience/HovmollerField.js

@@ -0,0 +1,180 @@
+import { HovmollerLongitudes, HovmollerReference, HovmollerSection } from "./HovmollerEnums.js";
+import { ascending, median, range } from "d3";
+// src/charts/earthscience/HovmollerField.ts
+var LIMIT = 400;
+var DAY = 864e5;
+var FULL = 360;
+var finite = (cell) => cell === null || cell === void 0 || cell === "" || cell instanceof Date ? null : Number.isFinite(+cell) ? +cell : null;
+var within = ([a, b], value, wraps) => a <= b ? value >= a && value <= b : wraps ? value >= a || value <= b : value >= b && value <= a;
+/** A section gridded for plotting: `values[p + t * columns]`, with NaN where nothing was observed. */
+var HovmollerField = class HovmollerField {
+	positions;
+	times;
+	values;
+	section;
+	dated;
+	daysPerUnit;
+	constructor(positions, times, values, section, dated, daysPerUnit) {
+		this.positions = positions;
+		this.times = times;
+		this.values = values;
+		this.section = section;
+		this.dated = dated;
+		this.daysPerUnit = daysPerUnit;
+	}
+	get columns() {
+		return this.positions.length;
+	}
+	get rows() {
+		return this.times.length;
+	}
+	/** Times in days since the first. */
+	get days() {
+		const unit = this.dated ? 1 / DAY : this.daysPerUnit;
+		return this.times.map((time) => (time - this.times[0]) * unit);
+	}
+	/** The time `day` days after the first. */
+	timeAt(day) {
+		return (this.times[0] ?? 0) + day * (this.dated ? DAY : 1 / this.daysPerUnit);
+	}
+	/** Median distance between positions. */
+	get spacing() {
+		return median(this.positions.slice(1).map((position, i) => position - this.positions[i])) ?? 0;
+	}
+	/** The positions run all the way round the globe, so the last is next to the first. */
+	get cyclic() {
+		if (this.section !== HovmollerSection.Longitude || this.columns < 3) return false;
+		return this.positions[0] + FULL - this.positions.at(-1) <= this.spacing * 1.5;
+	}
+	/** Grids rows or a ready grid. Rows that share a time and position are averaged, by cos φ when longitude sections pool latitudes. */
+	static read(data, read) {
+		const raw = Array.isArray(data) ? this.fromRows(data, read) : this.fromGrid(data, read);
+		const dated = raw.dated;
+		const positions = this.slots(raw.readings.map((d) => d.p)), times = this.slots(raw.readings.map((d) => d.t));
+		const columns = positions.centers.length, rows = times.centers.length;
+		const sum = new Float64Array(columns * rows), weight = new Float64Array(columns * rows);
+		for (const { t, p, v, w } of raw.readings) {
+			const k = positions.slot(p) + times.slot(t) * columns;
+			sum[k] += v * w;
+			weight[k] += w;
+		}
+		const values = sum.map((total, k) => weight[k] > 0 ? total / weight[k] : NaN);
+		return new HovmollerField(positions.centers, times.centers, values, read.section, dated, read.daysPerUnit);
+	}
+	static moment(cell) {
+		if (cell instanceof Date) return Number.isFinite(cell.getTime()) ? {
+			at: cell.getTime(),
+			dated: true
+		} : null;
+		const number = finite(cell);
+		if (number !== null) return {
+			at: number,
+			dated: false
+		};
+		const parsed = typeof cell === "string" ? Date.parse(cell) : NaN;
+		return Number.isFinite(parsed) ? {
+			at: parsed,
+			dated: true
+		} : null;
+	}
+	static wrap(longitude, mode) {
+		if (mode === HovmollerLongitudes.Given) return longitude;
+		const turned = (longitude % FULL + FULL) % FULL;
+		return mode === HovmollerLongitudes.Greenwich && turned >= 180 ? turned - FULL : turned;
+	}
+	static place(position, { section, longitudes }) {
+		if (section === HovmollerSection.Longitude) return this.wrap(position, longitudes);
+		return Math.abs(position) <= 90 ? position : null;
+	}
+	static fromRows(rows, read) {
+		const along = read.section === HovmollerSection.Longitude;
+		const [mine, other] = along ? [read.longitude, read.latitude] : [read.latitude, read.longitude];
+		let dated = null;
+		return {
+			readings: rows.flatMap((row) => {
+				if (row === null || typeof row !== "object") return [];
+				const moment = this.moment(row[read.time]), raw = finite(row[mine]), v = finite(row[read.value]), pooled = finite(row[other]);
+				const p = raw === null ? null : this.place(raw, read);
+				if (!moment || p === null || v === null) return [];
+				if (pooled !== null && read.band && !within(read.band, pooled, !along)) return [];
+				if (along && pooled !== null && Math.abs(pooled) > 90) return [];
+				dated ??= moment.dated;
+				if (moment.dated !== dated) return [];
+				return [{
+					t: moment.at,
+					p,
+					v,
+					w: along && pooled !== null ? Math.cos(pooled * Math.PI / 180) : 1
+				}];
+			}),
+			dated: dated ?? false
+		};
+	}
+	static fromGrid(grid, read) {
+		const moments = (grid?.y ?? []).map((cell) => this.moment(cell));
+		const dated = moments.find(Boolean)?.dated ?? false;
+		return {
+			readings: moments.flatMap((moment, j) => {
+				if (!moment || moment.dated !== dated) return [];
+				return (grid?.x ?? []).flatMap((position, i) => {
+					const v = finite(grid?.z[j]?.[i]), raw = finite(position);
+					const p = raw === null ? null : this.place(raw, read);
+					return v === null || p === null ? [] : [{
+						t: moment.at,
+						p,
+						v,
+						w: 1
+					}];
+				});
+			}),
+			dated
+		};
+	}
+	/** One slot per distinct value, or equal bins once scattered observations would make the grid too large. */
+	static slots(values) {
+		const centers = [...new Set(values)].sort(ascending);
+		if (centers.length <= LIMIT) {
+			const index = new Map(centers.map((value, i) => [value, i]));
+			return {
+				centers,
+				slot: (value) => index.get(value)
+			};
+		}
+		const low = centers[0], width = (centers.at(-1) - low) / LIMIT;
+		return {
+			centers: range(LIMIT).map((k) => low + (k + .5) * width),
+			slot: (value) => Math.min(399, Math.floor((value - low) / width))
+		};
+	}
+	/** Removes a mean. Means over latitude are weighted by cos φ, the area of each band. */
+	anomaly(reference) {
+		if (reference === HovmollerReference.None) return this;
+		const { columns, rows, positions } = this;
+		const byTime = reference === HovmollerReference.TimeMean;
+		const weight = positions.map((position) => this.section === HovmollerSection.Latitude ? Math.cos(position * Math.PI / 180) : 1);
+		const sum = new Float64Array(byTime ? columns : rows), mass = new Float64Array(byTime ? columns : rows);
+		const key = (k) => byTime ? k % columns : Math.floor(k / columns);
+		const area = (k) => byTime ? 1 : weight[k % columns];
+		this.values.forEach((value, k) => {
+			if (Number.isNaN(value)) return;
+			sum[key(k)] += value * area(k);
+			mass[key(k)] += area(k);
+		});
+		return this.with(positions, this.values.map((value, k) => value - sum[key(k)] / mass[key(k)]));
+	}
+	/** Repeats the first column at +360° so a global field runs right across the plot with no seam. */
+	closed() {
+		const { columns, rows, positions } = this;
+		if (!this.cyclic || positions.at(-1) - positions[0] >= FULL) return this;
+		const next = columns + 1, values = new Float64Array(next * rows);
+		for (let j = 0; j < rows; j++) {
+			values.set(this.values.subarray(j * columns, (j + 1) * columns), j * next);
+			values[columns + j * next] = this.values[j * columns];
+		}
+		return this.with([...positions, positions[0] + FULL], values);
+	}
+	with(positions, values) {
+		return new HovmollerField(positions, this.times, values, this.section, this.dated, this.daysPerUnit);
+	}
+};
+export { HovmollerField };