@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/distribution/enums.js

@@ -0,0 +1,299 @@
+// src/charts/distribution/enums.ts
+/** How several groups share one value axis. */
+var DistributionLayout = /* @__PURE__ */ function(DistributionLayout) {
+	DistributionLayout["Pooled"] = "pooled";
+	DistributionLayout["Overlaid"] = "overlaid";
+	DistributionLayout["Stacked"] = "stacked";
+	DistributionLayout["Dodged"] = "dodged";
+	DistributionLayout["Conditional"] = "conditional";
+	return DistributionLayout;
+}({});
+/** Bin-width rule. */
+var BinRule = /* @__PURE__ */ function(BinRule) {
+	BinRule["FreedmanDiaconis"] = "freedman-diaconis";
+	BinRule["Sturges"] = "sturges";
+	BinRule["Scott"] = "scott";
+	BinRule["SquareRoot"] = "square-root";
+	return BinRule;
+}({});
+/** What a bin's height means. */
+var FrequencyScale = /* @__PURE__ */ function(FrequencyScale) {
+	FrequencyScale["Count"] = "count";
+	FrequencyScale["Percent"] = "percent";
+	FrequencyScale["Density"] = "density";
+	FrequencyScale["Cumulative"] = "cumulative";
+	return FrequencyScale;
+}({});
+var HistogramShape = /* @__PURE__ */ function(HistogramShape) {
+	HistogramShape["Bars"] = "bars";
+	HistogramShape["Outline"] = "outline";
+	return HistogramShape;
+}({});
+var DistributionFit = /* @__PURE__ */ function(DistributionFit) {
+	DistributionFit["None"] = "no-fit";
+	DistributionFit["Normal"] = "normal-fit";
+	DistributionFit["Kde"] = "kde-fit";
+	return DistributionFit;
+}({});
+var KernelKind = /* @__PURE__ */ function(KernelKind) {
+	KernelKind["Gaussian"] = "gaussian";
+	KernelKind["Epanechnikov"] = "epanechnikov";
+	KernelKind["Triangular"] = "triangular";
+	KernelKind["Uniform"] = "uniform";
+	return KernelKind;
+}({});
+/** Bandwidth relative to Silverman's rule of thumb. */
+var KernelSmoothing = /* @__PURE__ */ function(KernelSmoothing) {
+	KernelSmoothing["Balanced"] = "balanced";
+	KernelSmoothing["Tight"] = "tight";
+	KernelSmoothing["Loose"] = "loose";
+	return KernelSmoothing;
+}({});
+/** What is equal between density shapes. */
+var DensityScaling = /* @__PURE__ */ function(DensityScaling) {
+	DensityScaling["Area"] = "equal-area";
+	DensityScaling["Count"] = "count-area";
+	DensityScaling["Width"] = "equal-width";
+	return DensityScaling;
+}({});
+/** Band order along the group axis, by median. */
+var GroupOrder = /* @__PURE__ */ function(GroupOrder) {
+	GroupOrder["Given"] = "given-order";
+	GroupOrder["Ascending"] = "ascending";
+	GroupOrder["Descending"] = "descending";
+	return GroupOrder;
+}({});
+var WhiskerRule = /* @__PURE__ */ function(WhiskerRule) {
+	WhiskerRule["Tukey"] = "tukey";
+	WhiskerRule["Percentile"] = "p5-p95";
+	WhiskerRule["Range"] = "min-max";
+	return WhiskerRule;
+}({});
+var BoxStyle = /* @__PURE__ */ function(BoxStyle) {
+	BoxStyle["Box"] = "box";
+	BoxStyle["Tufte"] = "tufte";
+	return BoxStyle;
+}({});
+var BoxWidth = /* @__PURE__ */ function(BoxWidth) {
+	BoxWidth["Equal"] = "equal-width";
+	BoxWidth["Count"] = "sqrt-n-width";
+	return BoxWidth;
+}({});
+var DensitySide = /* @__PURE__ */ function(DensitySide) {
+	DensitySide["Both"] = "mirrored";
+	DensitySide["Half"] = "half";
+	return DensitySide;
+}({});
+var ViolinInner = /* @__PURE__ */ function(ViolinInner) {
+	ViolinInner["None"] = "bare";
+	ViolinInner["Box"] = "inner-box";
+	ViolinInner["Quartiles"] = "inner-quartiles";
+	return ViolinInner;
+}({});
+var RidgeMode = /* @__PURE__ */ function(RidgeMode) {
+	RidgeMode["Density"] = "density";
+	RidgeMode["Histogram"] = "stepped";
+	return RidgeMode;
+}({});
+var RidgeMarker = /* @__PURE__ */ function(RidgeMarker) {
+	RidgeMarker["None"] = "plain";
+	RidgeMarker["Median"] = "median-line";
+	RidgeMarker["Quartiles"] = "quartile-lines";
+	RidgeMarker["Rug"] = "ridge-rug";
+	return RidgeMarker;
+}({});
+var RidgeScaling = /* @__PURE__ */ function(RidgeScaling) {
+	RidgeScaling["Shared"] = "shared-height";
+	RidgeScaling["Row"] = "row-height";
+	return RidgeScaling;
+}({});
+var SwarmLanes = /* @__PURE__ */ function(SwarmLanes) {
+	SwarmLanes["Grouped"] = "lanes";
+	SwarmLanes["Shared"] = "shared-lane";
+	return SwarmLanes;
+}({});
+var SwarmSide = /* @__PURE__ */ function(SwarmSide) {
+	SwarmSide["Both"] = "both-sides";
+	SwarmSide["Up"] = "one-side";
+	return SwarmSide;
+}({});
+var RainStyle = /* @__PURE__ */ function(RainStyle) {
+	RainStyle["Jitter"] = "jitter";
+	RainStyle["Swarm"] = "swarm";
+	RainStyle["Strip"] = "strip";
+	return RainStyle;
+}({});
+var LetterDepth = /* @__PURE__ */ function(LetterDepth) {
+	LetterDepth["Tukey"] = "tukey-depth";
+	LetterDepth["Proportion"] = "proportion-depth";
+	LetterDepth["Trustworthy"] = "trustworthy-depth";
+	return LetterDepth;
+}({});
+var BoxenScale = /* @__PURE__ */ function(BoxenScale) {
+	BoxenScale["Exponential"] = "exponential";
+	BoxenScale["Linear"] = "linear";
+	BoxenScale["Area"] = "area";
+	return BoxenScale;
+}({});
+var LetterForm = /* @__PURE__ */ function(LetterForm) {
+	LetterForm["Silhouette"] = "silhouette";
+	LetterForm["Ladder"] = "ladder";
+	return LetterForm;
+}({});
+var DotBinning = /* @__PURE__ */ function(DotBinning) {
+	DotBinning["Wilkinson"] = "wilkinson";
+	DotBinning["Histodot"] = "histodot";
+	return DotBinning;
+}({});
+var DotStackDirection = /* @__PURE__ */ function(DotStackDirection) {
+	DotStackDirection["Up"] = "stack-up";
+	DotStackDirection["Center"] = "stack-center";
+	DotStackDirection["Down"] = "stack-down";
+	return DotStackDirection;
+}({});
+var DotLayout = /* @__PURE__ */ function(DotLayout) {
+	DotLayout["Lanes"] = "group-lanes";
+	DotLayout["Pooled"] = "pooled-stack";
+	DotLayout["Coloured"] = "group-stack";
+	return DotLayout;
+}({});
+var CdfForm = /* @__PURE__ */ function(CdfForm) {
+	CdfForm["Cumulative"] = "ecdf";
+	CdfForm["Survival"] = "survival";
+	return CdfForm;
+}({});
+var CdfLine = /* @__PURE__ */ function(CdfLine) {
+	CdfLine["Step"] = "step";
+	CdfLine["Line"] = "line";
+	return CdfLine;
+}({});
+var CdfBand = /* @__PURE__ */ function(CdfBand) {
+	CdfBand["None"] = "no-band";
+	CdfBand["Confidence"] = "dkw-band";
+	return CdfBand;
+}({});
+var SinaSpread = /* @__PURE__ */ function(SinaSpread) {
+	SinaSpread["Uniform"] = "uniform-spread";
+	SinaSpread["Alternating"] = "alternating-spread";
+	return SinaSpread;
+}({});
+var SinaOverlay = /* @__PURE__ */ function(SinaOverlay) {
+	SinaOverlay["None"] = "dots-only";
+	SinaOverlay["Violin"] = "violin-overlay";
+	SinaOverlay["Box"] = "box-overlay";
+	SinaOverlay["Median"] = "median-overlay";
+	return SinaOverlay;
+}({});
+var BarcodeLength = /* @__PURE__ */ function(BarcodeLength) {
+	BarcodeLength["Constant"] = "constant";
+	BarcodeLength["Density"] = "density-length";
+	return BarcodeLength;
+}({});
+var BarcodeAlign = /* @__PURE__ */ function(BarcodeAlign) {
+	BarcodeAlign["Center"] = "centered";
+	BarcodeAlign["Base"] = "baseline";
+	return BarcodeAlign;
+}({});
+var BarcodeOverlay = /* @__PURE__ */ function(BarcodeOverlay) {
+	BarcodeOverlay["None"] = "ticks-only";
+	BarcodeOverlay["Median"] = "median-tick";
+	BarcodeOverlay["Quartiles"] = "quartile-bar";
+	return BarcodeOverlay;
+}({});
+var SlabForm = /* @__PURE__ */ function(SlabForm) {
+	SlabForm["Half"] = "half-eye";
+	SlabForm["Eye"] = "eye";
+	SlabForm["Interval"] = "point-interval";
+	SlabForm["Survival"] = "ccdf-bar";
+	return SlabForm;
+}({});
+var PointEstimate = /* @__PURE__ */ function(PointEstimate) {
+	PointEstimate["Median"] = "median";
+	PointEstimate["Mean"] = "mean";
+	PointEstimate["Mode"] = "mode";
+	return PointEstimate;
+}({});
+var IntervalSet = /* @__PURE__ */ function(IntervalSet) {
+	IntervalSet["Standard"] = "interval-66-95";
+	IntervalSet["Wide"] = "interval-50-80-95";
+	return IntervalSet;
+}({});
+var ParetoCutoff = /* @__PURE__ */ function(ParetoCutoff) {
+	ParetoCutoff["None"] = "no-cutoff";
+	ParetoCutoff["Line"] = "cutoff-line";
+	ParetoCutoff["Highlight"] = "vital-few";
+	return ParetoCutoff;
+}({});
+var ParetoLine = /* @__PURE__ */ function(ParetoLine) {
+	ParetoLine["Line"] = "cumulative-line";
+	ParetoLine["Step"] = "cumulative-step";
+	ParetoLine["None"] = "no-cumulative";
+	return ParetoLine;
+}({});
+var ParetoTail = /* @__PURE__ */ function(ParetoTail) {
+	ParetoTail["All"] = "all-categories";
+	ParetoTail["Other"] = "other-bucket";
+	return ParetoTail;
+}({});
+var StemLayout = /* @__PURE__ */ function(StemLayout) {
+	StemLayout["Single"] = "single";
+	StemLayout["BackToBack"] = "back-to-back";
+	return StemLayout;
+}({});
+var LeafMark = /* @__PURE__ */ function(LeafMark) {
+	LeafMark["Digit"] = "digits";
+	LeafMark["Dot"] = "leaf-dots";
+	LeafMark["Bar"] = "leaf-bars";
+	return LeafMark;
+}({});
+var StripMark = /* @__PURE__ */ function(StripMark) {
+	StripMark["Dot"] = "dot";
+	StripMark["Tick"] = "tick";
+	return StripMark;
+}({});
+var StripJitter = /* @__PURE__ */ function(StripJitter) {
+	StripJitter["Spread"] = "jitter";
+	StripJitter["None"] = "centered";
+	return StripJitter;
+}({});
+var StripSummary = /* @__PURE__ */ function(StripSummary) {
+	StripSummary["None"] = "no-summary";
+	StripSummary["Mean"] = "mean-bar";
+	StripSummary["Interval"] = "mean-interval";
+	return StripSummary;
+}({});
+var BeanLine = /* @__PURE__ */ function(BeanLine) {
+	BeanLine["Short"] = "short-beanlines";
+	BeanLine["Long"] = "long-beanlines";
+	BeanLine["None"] = "no-beanlines";
+	return BeanLine;
+}({});
+var StripeForm = /* @__PURE__ */ function(StripeForm) {
+	StripeForm["Gradient"] = "gradient";
+	StripeForm["Stepped"] = "stepped-levels";
+	return StripeForm;
+}({});
+var StripeProfile = /* @__PURE__ */ function(StripeProfile) {
+	StripeProfile["Flat"] = "flat-strip";
+	StripeProfile["Tapered"] = "tapered-strip";
+	return StripeProfile;
+}({});
+var StripeMarker = /* @__PURE__ */ function(StripeMarker) {
+	StripeMarker["None"] = "no-marker";
+	StripeMarker["Median"] = "median-marker";
+	StripeMarker["Quartiles"] = "quartile-marker";
+	return StripeMarker;
+}({});
+var Ridge3DForm = /* @__PURE__ */ function(Ridge3DForm) {
+	Ridge3DForm["Slabs"] = "slabs";
+	Ridge3DForm["Blades"] = "blades";
+	Ridge3DForm["Terrain"] = "terrain";
+	return Ridge3DForm;
+}({});
+var Violin3DForm = /* @__PURE__ */ function(Violin3DForm) {
+	Violin3DForm["Round"] = "round";
+	Violin3DForm["Faceted"] = "faceted";
+	Violin3DForm["Halved"] = "halved";
+	return Violin3DForm;
+}({});
+export { BarcodeAlign, BarcodeLength, BarcodeOverlay, BeanLine, BinRule, BoxStyle, BoxWidth, BoxenScale, CdfBand, CdfForm, CdfLine, DensityScaling, DensitySide, DistributionFit, DistributionLayout, DotBinning, DotLayout, DotStackDirection, FrequencyScale, GroupOrder, HistogramShape, IntervalSet, KernelKind, KernelSmoothing, LeafMark, LetterDepth, LetterForm, ParetoCutoff, ParetoLine, ParetoTail, PointEstimate, RainStyle, Ridge3DForm, RidgeMarker, RidgeMode, RidgeScaling, SinaOverlay, SinaSpread, SlabForm, StemLayout, StripJitter, StripMark, StripSummary, StripeForm, StripeMarker, StripeProfile, SwarmLanes, SwarmSide, Violin3DForm, ViolinInner, WhiskerRule };

package/dist/charts/distribution/index.js

@@ -0,0 +1,53 @@
+import { BarcodeAlign, BarcodeLength, BarcodeOverlay, BeanLine, BinRule, BoxStyle, BoxWidth, BoxenScale, CdfBand, CdfForm, CdfLine, DensityScaling, DensitySide, DistributionFit, DistributionLayout, DotBinning, DotLayout, DotStackDirection, FrequencyScale, GroupOrder, HistogramShape, IntervalSet, KernelKind, KernelSmoothing, LeafMark, LetterDepth, LetterForm, ParetoCutoff, ParetoLine, ParetoTail, PointEstimate, RainStyle, Ridge3DForm, RidgeMarker, RidgeMode, RidgeScaling, SinaOverlay, SinaSpread, SlabForm, StemLayout, StripJitter, StripMark, StripSummary, StripeForm, StripeMarker, StripeProfile, SwarmLanes, SwarmSide, Violin3DForm, ViolinInner, WhiskerRule } from "./enums.js";
+import { BackToBackHistogram } from "./BackToBackHistogram.js";
+import { BarcodePlot } from "./BarcodePlot.js";
+import { BeanPlot } from "./BeanPlot.js";
+import { BeeswarmChart } from "./BeeswarmChart.js";
+import { BoxenChart } from "./BoxenChart.js";
+import { BoxPlot } from "./BoxPlot.js";
+import { CumulativeDistribution } from "./CumulativeDistribution.js";
+import { DensityChart } from "./DensityChart.js";
+import { DensityStrip } from "./DensityStrip.js";
+import { Dotplot } from "./Dotplot.js";
+import { FrequencyPolygon } from "./FrequencyPolygon.js";
+import { HalfEyePlot } from "./HalfEyePlot.js";
+import { HistogramChart } from "./HistogramChart.js";
+import { LetterValuePlot } from "./LetterValuePlot.js";
+import { ParetoChart } from "./ParetoChart.js";
+import { QuantileDotplot } from "./QuantileDotplot.js";
+import { RaincloudChart } from "./RaincloudChart.js";
+import { RidgeSlabs3DChart } from "./RidgeSlabs3DChart.js";
+import { RidgelineChart } from "./RidgelineChart.js";
+import { SinaPlot } from "./SinaPlot.js";
+import { StemLeaf } from "./StemLeaf.js";
+import { StripPlot } from "./StripPlot.js";
+import { Violin3DChart } from "./Violin3DChart.js";
+import { ViolinChart } from "./ViolinChart.js";
+// src/charts/distribution/index.ts
+var distributionCatalog = [
+	HistogramChart,
+	DensityChart,
+	BoxPlot,
+	ViolinChart,
+	BeeswarmChart,
+	RidgelineChart,
+	RaincloudChart,
+	LetterValuePlot,
+	CumulativeDistribution,
+	QuantileDotplot,
+	FrequencyPolygon,
+	StemLeaf,
+	ParetoChart,
+	BoxenChart,
+	Dotplot,
+	SinaPlot,
+	BarcodePlot,
+	HalfEyePlot,
+	StripPlot,
+	BackToBackHistogram,
+	BeanPlot,
+	DensityStrip,
+	RidgeSlabs3DChart,
+	Violin3DChart
+];
+export { BackToBackHistogram, BarcodeAlign, BarcodeLength, BarcodeOverlay, BarcodePlot, BeanLine, BeanPlot, BeeswarmChart, BinRule, BoxPlot, BoxStyle, BoxWidth, BoxenChart, BoxenScale, CdfBand, CdfForm, CdfLine, CumulativeDistribution, DensityChart, DensityScaling, DensitySide, DensityStrip, DistributionFit, DistributionLayout, DotBinning, DotLayout, DotStackDirection, Dotplot, FrequencyPolygon, FrequencyScale, GroupOrder, HalfEyePlot, HistogramChart, HistogramShape, IntervalSet, KernelKind, KernelSmoothing, LeafMark, LetterDepth, LetterForm, LetterValuePlot, ParetoChart, ParetoCutoff, ParetoLine, ParetoTail, PointEstimate, QuantileDotplot, RainStyle, RaincloudChart, Ridge3DForm, RidgeMarker, RidgeMode, RidgeScaling, RidgeSlabs3DChart, RidgelineChart, SinaOverlay, SinaPlot, SinaSpread, SlabForm, StemLayout, StemLeaf, StripJitter, StripMark, StripPlot, StripSummary, StripeForm, StripeMarker, StripeProfile, SwarmLanes, SwarmSide, Violin3DChart, Violin3DForm, ViolinChart, ViolinInner, WhiskerRule, distributionCatalog };

package/dist/charts/earthscience/BaseflowSeparation.js

@@ -0,0 +1,104 @@
+import { max, min } from "d3";
+// src/charts/earthscience/BaseflowSeparation.ts
+var BaseflowMethod = /* @__PURE__ */ function(BaseflowMethod) {
+	BaseflowMethod["None"] = "none";
+	BaseflowMethod["ConstantDischarge"] = "constant-discharge";
+	BaseflowMethod["ConstantSlope"] = "constant-slope";
+	BaseflowMethod["Concave"] = "concave";
+	BaseflowMethod["LyneHollick"] = "lyne-hollick";
+	BaseflowMethod["Eckhardt"] = "eckhardt";
+	return BaseflowMethod;
+}({});
+var PROMINENCE = .1;
+/** Splits a discharge series into baseflow and direct runoff, by the graphical or recursive-filter methods of hydrology texts. */
+var BaseflowSeparation = class {
+	/** Linsley's rule: direct runoff ends N = 0.827 A^0.2 days after the peak, with A in km². */
+	static recessionHours(area) {
+		return 19.848 * Math.max(area, .001) ** .2;
+	}
+	/** Storm responses, merged where one starts before the last has ended. A peak must stand 10% of the series range above its rise. */
+	static events(flow, hours, area) {
+		const last = flow.length - 1;
+		const range = (max(flow) ?? 0) - (min(flow) ?? 0);
+		if (!(range > 0)) return [];
+		const reach = this.recessionHours(area);
+		const found = [];
+		for (let peak = 1; peak <= last; peak++) {
+			if (!(flow[peak] > flow[peak - 1] && flow[peak] >= (flow[peak + 1] ?? -Infinity))) continue;
+			let rise = peak;
+			for (let i = peak - 1; i >= 0 && flow[i] <= flow[peak]; i--) if (flow[i] < flow[rise]) rise = i;
+			if (flow[peak] - flow[rise] < range * PROMINENCE) continue;
+			let end = peak;
+			while (end < last && hours[end] < hours[peak] + reach) end++;
+			found.push({
+				rise,
+				peak,
+				end
+			});
+		}
+		found.sort((a, b) => a.rise - b.rise);
+		const merged = [];
+		for (const event of found) {
+			const open = merged.at(-1);
+			if (!open || event.rise >= open.end) {
+				merged.push({ ...event });
+				continue;
+			}
+			open.end = Math.max(open.end, event.end);
+			if (flow[event.peak] > flow[open.peak]) open.peak = event.peak;
+		}
+		return merged;
+	}
+	static separate(method, flow, hours, area, settings = {}) {
+		const step = hours.length > 1 ? (hours.at(-1) - hours[0]) / (hours.length - 1) : 24;
+		if (method === "none") return [...flow];
+		if (method === "lyne-hollick") return this.lyneHollick(flow, (settings.recession ?? .925) ** (step / 24));
+		if (method === "eckhardt") return this.eckhardt(flow, (settings.recession ?? .98) ** (step / 24), settings.bfiMax ?? .8);
+		const base = [...flow];
+		for (const event of this.events(flow, hours, area)) {
+			const line = this.graphical(method, event, flow, hours);
+			for (let i = event.rise; i <= event.end; i++) base[i] = Math.min(flow[i], line(hours[i]));
+		}
+		return base;
+	}
+	static graphical(method, { rise, peak, end }, flow, hours) {
+		const start = flow[rise], from = hours[rise], to = hours[end], close = flow[end];
+		if (method === "constant-discharge") return () => start;
+		if (method === "constant-slope") return (hour) => to > from ? start + (close - start) * (hour - from) / (to - from) : start;
+		const back = Math.max(0, rise - 6);
+		const decay = back < rise && flow[back] > start && start > 0 ? (start / flow[back]) ** (1 / (from - hours[back])) : 1;
+		const under = start * decay ** (hours[peak] - from), turn = hours[peak];
+		return (hour) => hour <= turn ? start * decay ** (hour - from) : under + (close - under) * (hour - turn) / (to - turn);
+	}
+	/** Three passes, forward, back and forward, as Ladson et al. (2013) recommend. */
+	static lyneHollick(flow, alpha) {
+		let series = [...flow];
+		for (let pass = 0; pass < 3; pass++) {
+			let quick = 0;
+			series = series.map((value, i) => {
+				if (i) quick = alpha * quick + (1 + alpha) / 2 * (value - series[i - 1]);
+				return value - Math.max(0, quick);
+			}).reverse();
+		}
+		return series.reverse().map((value, i) => Math.max(0, Math.min(value, flow[i])));
+	}
+	static eckhardt(flow, a, bfiMax) {
+		let base = flow[0] ?? 0;
+		return flow.map((value) => {
+			base = Math.min(value, ((1 - bfiMax) * a * base + (1 - a) * bfiMax * value) / (1 - a * bfiMax));
+			return base;
+		});
+	}
+	/** Constant loss rate that leaves exactly `runoff` of rainfall as excess, in the units of `rain`. */
+	static phiIndex(rain, runoff) {
+		const sorted = rain.filter((value) => value > 0).sort((a, b) => b - a);
+		let total = 0;
+		for (let k = 1; k <= sorted.length; k++) {
+			total += sorted[k - 1];
+			const phi = (total - runoff) / k;
+			if (phi >= (sorted[k] ?? 0)) return Math.max(0, phi);
+		}
+		return 0;
+	}
+};
+export { BaseflowMethod, BaseflowSeparation };

package/dist/charts/earthscience/EarthSample.js

@@ -0,0 +1,79 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/earthscience/EarthSample.ts
+var NASH_LAG = 2.5;
+/** Storm depth in mm, spread in hours and start hour, for a large storm and a following smaller one. */
+var STORMS = [[
+	46,
+	3.2,
+	16
+], [
+	22,
+	2.4,
+	62
+]];
+/** Log-ratio centres of sand, silt and clay for a beach, an estuary and a shelf. */
+var FACIES = [
+	[
+		1.7,
+		.4,
+		0
+	],
+	[
+		.1,
+		1.1,
+		0
+	],
+	[
+		-.7,
+		.2,
+		0
+	]
+];
+/** Earth-science demo data, reshaped from `SampleData`. */
+var EarthSample = class {
+	/** Default catchment area of `hydrograph`, in km². */
+	static area = 60;
+	/** Hourly gauge record `{ time, flow, rain }`: two storms routed through a Nash cascade, over a slow recession of baseflow. */
+	static hydrograph(seed, hours = 120) {
+		const walk = SampleData.timeSeries(seed, hours, 1);
+		const gust = walk.map((row, i) => i ? Math.abs(+row.value - +walk[i - 1].value) : 0);
+		const shift = Math.round(gust[1] * 2);
+		const rain = gust.map((value, t) => {
+			const wet = STORMS.reduce((sum, [mm, spread, at]) => sum + mm / (spread * 2.507) * Math.exp(-(((t - at - shift) / spread) ** 2) / 2), 0) * (.55 + Math.min(value, 4) / 4);
+			return wet < .2 ? 0 : +wet.toFixed(1);
+		});
+		const unit = Array.from({ length: 36 }, (_, j) => (j / NASH_LAG) ** 2 * Math.exp(-j / NASH_LAG) / (2 * NASH_LAG));
+		const start = walk[0].date.getTime();
+		let store = 6 + +walk[0].value % 1;
+		return rain.map((depth, t) => {
+			store = store * .99 + depth * .07;
+			const runoff = unit.reduce((sum, weight, j) => sum + weight * (rain[t - j] ?? 0) * .42, 0);
+			return {
+				time: new Date(start + t * 36e5),
+				flow: +(store + runoff * this.area / 3.6).toFixed(2),
+				rain: depth
+			};
+		});
+	}
+	/** Sediment samples `{ sand, silt, clay, porosity }` in percent, from three facies. Porosity falls where sand fills the voids of clay. */
+	static sediments(seed, count = 84) {
+		return SampleData.points(seed, count, 3).map((row, i) => {
+			const facies = i % 3, wobble = [
+				(+row.x - (20 + facies * 22)) / 8,
+				(+row.y - .8 * +row.x - 10) / 9,
+				0
+			];
+			const parts = FACIES[facies].map((centre, k) => Math.exp(centre + wobble[k] * .6));
+			const total = parts[0] + parts[1] + parts[2];
+			const [sand, silt, clay] = parts.map((part) => part / total);
+			const porosity = 38 * sand + 52 * silt + 72 * clay - 46 * sand * clay + (+row.size - 18) * .08;
+			return {
+				sand: +(sand * 100).toFixed(1),
+				silt: +(silt * 100).toFixed(1),
+				clay: +(clay * 100).toFixed(1),
+				porosity: +porosity.toFixed(1)
+			};
+		});
+	}
+};
+export { EarthSample };