@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/statistics/CalibrationPlot.js

@@ -0,0 +1,213 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { ClassifierCurveBase } from "./ClassifierCurveBase.js";
+import { StatMath } from "./StatMath.js";
+import { bin, group, mean, quantileSorted, sum } from "d3";
+// src/charts/statistics/CalibrationPlot.ts
+/** How predictions are grouped. */
+var CalibrationBinning = /* @__PURE__ */ function(CalibrationBinning) {
+	CalibrationBinning["Uniform"] = "uniform-bins";
+	CalibrationBinning["Quantile"] = "quantile-bins";
+	return CalibrationBinning;
+}({});
+/** How the uncertainty of each observed rate is drawn. */
+var CalibrationUncertainty = /* @__PURE__ */ function(CalibrationUncertainty) {
+	CalibrationUncertainty["None"] = "no-interval";
+	CalibrationUncertainty["Bars"] = "interval-bars";
+	CalibrationUncertainty["Ribbon"] = "interval-ribbon";
+	return CalibrationUncertainty;
+}({});
+/** Companion view of where predictions fall. */
+var PredictionDistribution = /* @__PURE__ */ function(PredictionDistribution) {
+	PredictionDistribution["None"] = "no-distribution";
+	PredictionDistribution["Histogram"] = "histogram";
+	PredictionDistribution["Rug"] = "rug";
+	return PredictionDistribution;
+}({});
+/** Asks whether a predicted 70% really happens 70% of the time, and reveals over- or under-confidence. */
+var CalibrationPlot = class extends ClassifierCurveBase {
+	static meta = {
+		id: "calibration-plot",
+		name: "Calibration plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Compares predicted probabilities with observed frequencies to show whether a model can be trusted as stated.",
+		tags: [
+			"reliability diagram",
+			"classifier",
+			"probability",
+			"machine learning"
+		],
+		sample: (seed) => ClassifierCurveBase.scored(seed),
+		variants: {
+			binning: Object.values(CalibrationBinning),
+			bins: [
+				10,
+				5,
+				15
+			],
+			uncertainty: Object.values(CalibrationUncertainty),
+			distribution: Object.values(PredictionDistribution),
+			smooth: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			binning: "uniform-bins",
+			bins: 10,
+			uncertainty: "no-interval",
+			distribution: "no-distribution",
+			smooth: false
+		};
+	}
+	axisTitles() {
+		return {
+			x: "Predicted probability",
+			y: "Observed frequency"
+		};
+	}
+	bins(model) {
+		const { bins, binning } = this.options;
+		const sorted = model.cases.map((d) => d.score).sort((a, b) => a - b);
+		const edges = binning === "uniform-bins" ? Array.from({ length: bins + 1 }, (_, i) => i / bins) : Array.from({ length: bins + 1 }, (_, i) => quantileSorted(sorted, i / bins) ?? 0);
+		const index = (score) => {
+			let i = 0;
+			while (i < bins - 1 && score > edges[i + 1]) i++;
+			return i;
+		};
+		return [...group(model.cases, (d) => index(d.score))].map(([slot, cases]) => {
+			const hits = sum(cases, (d) => +d.hit);
+			const [low, high] = StatMath.wilson(hits, cases.length);
+			return {
+				model,
+				index: slot,
+				predicted: mean(cases, (d) => d.score),
+				observed: hits / cases.length,
+				low,
+				high,
+				n: cases.length
+			};
+		}).sort((a, b) => a.predicted - b.predicted);
+	}
+	/** Expected calibration error. */
+	ece(model) {
+		return sum(this.bins(model), (d) => d.n / (model.cases.length || 1) * Math.abs(d.predicted - d.observed));
+	}
+	legendMetric(model) {
+		return ["ECE", this.ece(model)];
+	}
+	scales(ctx) {
+		const strip = this.options.distribution === "no-distribution" ? 0 : Math.min(44, ctx.plot.height * .2);
+		return {
+			x: this.linear([0, 1], [0, ctx.plot.width]),
+			y: this.linear([0, 1], [ctx.plot.height - strip, 0])
+		};
+	}
+	drawDistribution(ctx, models, axes) {
+		const { distribution, bins } = this.options;
+		const { height } = ctx.plot;
+		const strip = height - axes.y(0) - 6;
+		const bars = distribution === "histogram" ? models.flatMap((model) => bin().domain([0, 1]).thresholds(bins * 2)(model.cases.map((d) => d.score)).map((b) => ({
+			model,
+			x0: b.x0,
+			x1: b.x1,
+			n: b.length
+		}))) : [];
+		const top = Math.max(1, ...bars.map((d) => d.n));
+		const slot = (d) => models.indexOf(d.model);
+		const width = (d) => Math.max(1, (axes.x(d.x1) - axes.x(d.x0) - 2) / (models.length || 1));
+		const rects = ctx.marks("histogram", "rect", bars, (d) => `${d.model.key}/${d.x0}`).attr("fill", (d) => this.color(ctx, d.model)).attr("fill-opacity", .75).attr("rx", 1);
+		const h = (d) => d.n / top * strip;
+		const x = (d) => axes.x(d.x0) + 1 + slot(d) * width(d);
+		ctx.set(rects, {
+			x,
+			width,
+			y: (d) => height - h(d),
+			height: h
+		}, {
+			x,
+			width,
+			y: height,
+			height: 0
+		});
+		ctx.hover(rects, (d) => ({
+			title: d.model.key,
+			color: this.color(ctx, d.model),
+			rows: [["Predicted", `${d.x0.toFixed(2)} to ${d.x1.toFixed(2)}`], ["Cases", d.n]]
+		}));
+		const rows = strip / (models.length || 1);
+		const ticks = distribution === "rug" ? models.flatMap((model, m) => model.cases.filter((_, i) => i % 2 === 0).map((d, i) => ({
+			model,
+			m,
+			score: d.score,
+			i
+		}))) : [];
+		const rug = ctx.marks("rug", "line", ticks, (d) => `${d.model.key}/${d.i}`).attr("stroke", (d) => this.color(ctx, d.model)).attr("stroke-width", 1).attr("stroke-opacity", .6);
+		ctx.set(rug, {
+			x1: (d) => axes.x(d.score),
+			x2: (d) => axes.x(d.score),
+			y1: (d) => height - rows * (d.m + 1) + 1,
+			y2: (d) => height - rows * d.m - 1
+		});
+		ctx.hover(rug, (d) => ({
+			title: d.model.key,
+			color: this.color(ctx, d.model),
+			rows: [["Predicted", d.score]]
+		}));
+	}
+	plotMarks(ctx, axes) {
+		const { uncertainty, smooth } = this.options;
+		const models = this.models(), color = (model) => this.color(ctx, model);
+		this.rules(ctx, "perfect", [{
+			key: "perfect",
+			from: [0, 0],
+			to: [1, 1],
+			dash: "5 4"
+		}], axes);
+		this.ribbons(ctx, "ribbon", uncertainty === "interval-ribbon" ? models.map((model) => ({
+			key: model.key,
+			color: color(model),
+			opacity: .1,
+			points: this.bins(model).map((d) => [
+				d.predicted,
+				d.low,
+				d.high
+			])
+		})) : [], axes);
+		const bins = models.flatMap((model) => this.bins(model));
+		const whiskers = ctx.marks("whiskers", "line", uncertainty === "interval-bars" ? bins : [], (d) => `${d.model.key}/${d.index}`).attr("stroke", (d) => color(d.model)).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke-opacity", .55);
+		ctx.set(whiskers, {
+			x1: (d) => axes.x(d.predicted),
+			x2: (d) => axes.x(d.predicted),
+			y1: (d) => axes.y(d.low),
+			y2: (d) => axes.y(d.high)
+		});
+		this.traces(ctx, "curves", models.map((model) => ({
+			key: model.key,
+			color: color(model),
+			points: this.bins(model).map((d) => [d.predicted, d.observed])
+		})), axes);
+		this.traces(ctx, "smooth", smooth ? models.map((model) => ({
+			key: `${model.key} smooth`,
+			color: color(model),
+			dash: "2 4",
+			tip: {
+				title: `${model.key}, LOWESS`,
+				color: color(model)
+			},
+			points: StatMath.lowess(model.cases.filter((_, i) => i % 3 === 0).map((d) => [d.score, +d.hit]), .5).map(([x, y]) => [x, Math.max(0, Math.min(1, y))])
+		})) : [], axes);
+		this.dots(ctx, "bins", bins, (d) => [axes.x(d.predicted), axes.y(d.observed)], (d) => color(d.model), (d) => ({
+			title: d.model.key,
+			color: color(d.model),
+			rows: [
+				["Predicted", +d.predicted.toFixed(3)],
+				["Observed", +d.observed.toFixed(3)],
+				["Cases", d.n]
+			]
+		}), { key: (d) => `${d.model.key}/${d.index}` });
+		this.drawDistribution(ctx, models, axes);
+	}
+};
+export { CalibrationBinning, CalibrationPlot, CalibrationUncertainty, PredictionDistribution };

package/dist/charts/statistics/ClassifierCurveBase.js

@@ -0,0 +1,94 @@
+import { SampleData } from "../../data/SampleData.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+import { descending, group, sum } from "d3";
+// src/charts/statistics/ClassifierCurveBase.ts
+/** Shared threshold sweep for charts that score a binary classifier, one trace per model. */
+var ClassifierCurveBase = class extends StatisticalChart {
+	/** Three models of rising skill over the same 30% prevalence. */
+	static scored(seed) {
+		const rows = SampleData.distribution(seed, 140, 4);
+		const of = (name) => rows.filter((row) => row.group === name).map((row) => +row.value);
+		const probability = (value) => +(1 / (1 + Math.exp(-(value - 54) / 6))).toFixed(4);
+		return [
+			["Boosted", "Delta"],
+			["Logistic", "Charlie"],
+			["Baseline", "Bravo"]
+		].flatMap(([model, positive]) => [...of("Alpha").map((value) => ({
+			model,
+			score: probability(value),
+			actual: 0
+		})), ...of(positive).slice(0, 60).map((value) => ({
+			model,
+			score: probability(value),
+			actual: 1
+		}))]);
+	}
+	defaults() {
+		return {
+			score: "score",
+			actual: "actual",
+			model: "model",
+			positive: 1
+		};
+	}
+	models() {
+		const { data, score, actual, model, positive } = this.options;
+		const rows = this.complete(data, score).filter((row) => row[actual] !== null && row[actual] !== void 0);
+		return [...group(rows, (row) => String(row[model] ?? "Model"))].map(([key, part]) => {
+			const cases = part.map((row) => ({
+				score: +row[score],
+				hit: row[actual] === positive || String(row[actual]) === String(positive)
+			})).sort((a, b) => descending(a.score, b.score));
+			const positives = sum(cases, (d) => +d.hit), negatives = cases.length - positives;
+			const sweep = [];
+			let tp = 0, fp = 0;
+			cases.forEach((d, i) => {
+				if (d.hit) tp++;
+				else fp++;
+				if (cases[i + 1]?.score !== d.score) sweep.push({
+					threshold: d.score,
+					tp,
+					fp,
+					tpr: tp / (positives || 1),
+					fpr: fp / (negatives || 1),
+					precision: tp / (tp + fp)
+				});
+			});
+			return {
+				key,
+				cases,
+				positives,
+				negatives,
+				sweep
+			};
+		});
+	}
+	/** Area under the empirical ROC curve. */
+	auc(model) {
+		let total = 0, x = 0, y = 0;
+		for (const { fpr, tpr } of model.sweep) {
+			total += (fpr - x) * (tpr + y) / 2;
+			x = fpr;
+			y = tpr;
+		}
+		return total;
+	}
+	/** Summary value beside a model's name in the legend, with the metric's name on the first entry only. */
+	legendMetric(_model) {
+		return null;
+	}
+	legendItems() {
+		const models = new Map(this.models().map((model) => [model.key, model]));
+		return this.palette.items().map((item, i) => {
+			const model = models.get(item.key), metric = model && this.legendMetric(model);
+			return metric ? {
+				...item,
+				label: `${item.key} ${i ? "" : `${metric[0]} `}${metric[1].toFixed(2).replace(/^0/, "")}`
+			} : item;
+		});
+	}
+	color(ctx, model) {
+		return ctx.palette.color(model.key);
+	}
+};
+export { ClassifierCurveBase };

package/dist/charts/statistics/ControlChart.js

@@ -0,0 +1,215 @@
+import { ProcessChartBase } from "./ProcessChartBase.js";
+import { ProcessRuleset } from "./ProcessRules.js";
+import { deviation, max, mean, min } from "d3";
+// src/charts/statistics/ControlChart.ts
+/** Statistic plotted by a Shewhart variables chart. */
+var ControlStatistic = /* @__PURE__ */ function(ControlStatistic) {
+	ControlStatistic["Individuals"] = "individuals";
+	ControlStatistic["MovingRange"] = "moving-range";
+	ControlStatistic["Mean"] = "x-bar";
+	ControlStatistic["Range"] = "range";
+	ControlStatistic["StandardDeviation"] = "std-dev";
+	return ControlStatistic;
+}({});
+var D2 = [
+	0,
+	0,
+	1.128,
+	1.693,
+	2.059,
+	2.326,
+	2.534,
+	2.704,
+	2.847,
+	2.97,
+	3.078
+];
+var D3 = [
+	0,
+	0,
+	.853,
+	.888,
+	.88,
+	.864,
+	.848,
+	.833,
+	.82,
+	.808,
+	.797
+];
+var c4 = (n) => 1 - 1 / (4 * n) - 7 / (32 * n * n) - 19 / (128 * n ** 3);
+var constants = (size) => {
+	const n = Math.max(2, Math.min(10, size)), d2 = D2[n], d3 = D3[n], c = c4(n);
+	return {
+		d2,
+		A2: 3 / (d2 * Math.sqrt(n)),
+		A3: 3 / (c * Math.sqrt(n)),
+		D3: Math.max(0, 1 - 3 * d3 / d2),
+		D4: 1 + 3 * d3 / d2,
+		B3: Math.max(0, 1 - 3 * Math.sqrt(1 - c * c) / c),
+		B4: 1 + 3 * Math.sqrt(1 - c * c) / c
+	};
+};
+/** Shewhart chart for measured data: separates routine variation from a process that has actually changed. */
+var ControlChart = class extends ProcessChartBase {
+	static meta = {
+		id: "control-chart",
+		name: "Control chart",
+		...ProcessChartBase.family,
+		description: "Tracks a process statistic against control limits to separate routine variation from real change.",
+		tags: [
+			"shewhart",
+			"spc",
+			"x-bar",
+			"quality",
+			"individuals"
+		],
+		sample: (seed) => ProcessChartBase.measurements(seed),
+		variants: {
+			statistic: Object.values(ControlStatistic),
+			rules: Object.values(ProcessRuleset),
+			zones: [false, true],
+			phased: [false, true],
+			connect: [true, false]
+		},
+		/** Run tests assume a symmetric statistic, and Nelson's long runs need more points than subgroups give. */
+		valid: ({ statistic, rules }) => rules === ProcessRuleset.Limits || statistic === "individuals" || statistic === "x-bar" && rules === ProcessRuleset.WesternElectric
+	};
+	defaults() {
+		return {
+			value: "value",
+			subgroup: void 0,
+			subgroupSize: 5,
+			statistic: "individuals",
+			rules: ProcessRuleset.Limits,
+			zones: false,
+			phased: false,
+			connect: true
+		};
+	}
+	statisticName() {
+		return {
+			["individuals"]: "Individual value",
+			["moving-range"]: "Moving range",
+			["x-bar"]: "Subgroup mean",
+			["range"]: "Subgroup range",
+			["std-dev"]: "Subgroup SD"
+		}[this.options.statistic];
+	}
+	axisTitles() {
+		return {
+			x: this.options.statistic === "individuals" || this.options.statistic === "moving-range" ? "Sample" : "Subgroup",
+			y: this.statisticName()
+		};
+	}
+	get baselineShare() {
+		return this.options.phased ? 2 / 3 : 1;
+	}
+	subgroups() {
+		const { data, value, subgroup, subgroupSize } = this.options;
+		const rows = this.complete(data, value);
+		if (subgroup) {
+			const groups = /* @__PURE__ */ new Map();
+			for (const row of rows) groups.set(row[subgroup], [...groups.get(row[subgroup]) ?? [], +row[value]]);
+			return [...groups].map(([label, values]) => ({
+				label: String(label),
+				values
+			}));
+		}
+		const size = Math.max(2, subgroupSize);
+		return Array.from({ length: Math.floor(rows.length / size) }, (_, i) => ({ values: rows.slice(i * size, (i + 1) * size).map((row) => +row[value]) }));
+	}
+	points() {
+		const { statistic } = this.options;
+		return statistic === "individuals" || statistic === "moving-range" ? this.single() : this.grouped();
+	}
+	single() {
+		const { data, value, statistic } = this.options;
+		const values = this.complete(data, value).map((row) => +row[value]);
+		const ranges = values.slice(1).map((v, i) => Math.abs(v - values[i]));
+		const cut = Math.max(2, Math.ceil(values.length * this.baselineShare));
+		const barRange = mean(ranges.slice(0, cut - 1)) ?? 0;
+		if (statistic === "moving-range") return ranges.map((range, i) => ({
+			slot: i + 1,
+			value: range,
+			center: barRange,
+			upper: 3.267 * barRange,
+			lower: 0
+		}));
+		const center = mean(values.slice(0, cut)) ?? 0, reach = 3 * barRange / 1.128;
+		return values.map((v, i) => ({
+			slot: i + 1,
+			value: v,
+			center,
+			upper: center + reach,
+			lower: center - reach
+		}));
+	}
+	grouped() {
+		const { statistic } = this.options;
+		const groups = this.subgroups().filter((d) => d.values.length > 1);
+		const cut = Math.max(1, Math.ceil(groups.length * this.baselineShare));
+		const k = constants(Math.round(mean(groups, (d) => d.values.length) ?? 2));
+		const stats = groups.map((d) => ({
+			label: d.label,
+			mean: mean(d.values),
+			range: max(d.values) - min(d.values),
+			sd: deviation(d.values) ?? 0
+		}));
+		const base = stats.slice(0, cut), grand = mean(base, (d) => d.mean) ?? 0, barRange = mean(base, (d) => d.range) ?? 0, barSd = mean(base, (d) => d.sd) ?? 0;
+		return stats.map((d, i) => {
+			const common = {
+				slot: i + 1,
+				label: d.label
+			};
+			if (statistic === "range") return {
+				...common,
+				value: d.range,
+				center: barRange,
+				upper: k.D4 * barRange,
+				lower: k.D3 * barRange
+			};
+			if (statistic === "std-dev") return {
+				...common,
+				value: d.sd,
+				center: barSd,
+				upper: k.B4 * barSd,
+				lower: k.B3 * barSd
+			};
+			return {
+				...common,
+				value: d.mean,
+				center: grand,
+				upper: grand + k.A2 * barRange,
+				lower: grand - k.A2 * barRange
+			};
+		});
+	}
+	underlay(ctx, points, axes) {
+		const at = Math.ceil(points.length * this.baselineShare) + .5;
+		const [low, high] = axes.y.domain();
+		const phased = this.options.phased && points.length > 2;
+		this.rules(ctx, "phase", phased ? [{
+			key: "phase",
+			from: [at, low],
+			to: [at, high],
+			dash: "2 3",
+			strong: true
+		}] : [], axes);
+		this.notes(ctx, "phase-labels", phased ? [{
+			key: "one",
+			text: "Baseline",
+			x: axes.x(at) - 5,
+			y: ctx.plot.height - 14,
+			anchor: "end",
+			tone: "muted"
+		}, {
+			key: "two",
+			text: "Monitoring",
+			x: axes.x(at) + 5,
+			y: ctx.plot.height - 14,
+			tone: "muted"
+		}] : []);
+	}
+};
+export { ControlChart, ControlStatistic };

package/dist/charts/statistics/CooksDistancePlot.js

@@ -0,0 +1,161 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { RegressionFit } from "./RegressionFit.js";
+import { RegressionForm } from "./ResidualPlot.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+// src/charts/statistics/CooksDistancePlot.ts
+/** Case-deletion measure on the vertical axis. */
+var InfluenceMeasure = /* @__PURE__ */ function(InfluenceMeasure) {
+	InfluenceMeasure["Cooks"] = "cooks-distance";
+	InfluenceMeasure["Dffits"] = "dffits";
+	InfluenceMeasure["Leverage"] = "leverage";
+	return InfluenceMeasure;
+}({});
+/** Order of observations along the axis. */
+var InfluenceOrder = /* @__PURE__ */ function(InfluenceOrder) {
+	InfluenceOrder["Observation"] = "by-observation";
+	InfluenceOrder["Ranked"] = "ranked";
+	return InfluenceOrder;
+}({});
+/** Mark drawn per observation. */
+var InfluenceMarks = /* @__PURE__ */ function(InfluenceMarks) {
+	InfluenceMarks["Stems"] = "stems";
+	InfluenceMarks["Bars"] = "bars";
+	return InfluenceMarks;
+}({});
+/** One bar per observation showing how far the whole fit moves if that row is removed. */
+var CooksDistancePlot = class extends StatisticalChart {
+	static meta = {
+		id: "cooks-distance-plot",
+		name: "Cook's distance plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows how much the regression fit would change if each observation were deleted, to flag influential rows.",
+		tags: [
+			"regression",
+			"influence",
+			"dffits",
+			"hat values",
+			"diagnostic"
+		],
+		sample: (seed) => SampleData.points(seed, 40, 3),
+		variants: {
+			model: Object.values(RegressionForm),
+			measure: Object.values(InfluenceMeasure),
+			order: Object.values(InfluenceOrder),
+			marks: Object.values(InfluenceMarks),
+			cutoff: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			x: "x",
+			y: "y",
+			model: RegressionForm.Linear,
+			measure: "cooks-distance",
+			order: "by-observation",
+			marks: "stems",
+			cutoff: true
+		};
+	}
+	axisTitles() {
+		return {
+			x: this.options.order === "ranked" ? "Rank" : "Observation",
+			y: {
+				["cooks-distance"]: "Cook's distance",
+				["dffits"]: "DFFITS",
+				["leverage"]: "Leverage"
+			}[this.options.measure]
+		};
+	}
+	cut = 0;
+	bars() {
+		const { data, x, y, model, measure, order } = this.options;
+		const rows = this.complete(data, x, y), n = rows.length;
+		if (n < 4) return [];
+		const fit = new RegressionFit(rows.map((row) => +row[x]), rows.map((row) => +row[y]), model === RegressionForm.Quadratic ? 2 : 1);
+		const p = fit.parameters, { studentized, cooks, leverage } = fit;
+		const values = measure === "cooks-distance" ? cooks : measure === "leverage" ? leverage : studentized.map((t, i) => t * Math.sqrt(leverage[i] / Math.max(1e-9, 1 - leverage[i])));
+		this.cut = measure === "cooks-distance" ? 4 / n : measure === "leverage" ? 2 * p / n : 2 * Math.sqrt(p / n);
+		const ranked = values.map((value, index) => ({
+			index,
+			value
+		}));
+		if (order === "ranked") ranked.sort((a, b) => Math.abs(b.value) - Math.abs(a.value));
+		return ranked.map((d, slot) => ({
+			...d,
+			slot: slot + 1
+		}));
+	}
+	scales(ctx) {
+		const bars = this.bars(), { cutoff, measure } = this.options;
+		const reach = Math.max(1e-9, ...bars.map((d) => Math.abs(d.value)), cutoff ? this.cut : 0) * 1.08;
+		return {
+			x: this.linear([0, bars.length + 1], [0, ctx.plot.width]),
+			y: this.linear(measure === "dffits" ? [-reach, reach] : [0, reach], [ctx.plot.height, 0])
+		};
+	}
+	plotMarks(ctx, axes) {
+		const { marks, cutoff, measure } = this.options;
+		const bars = this.bars(), count = bars.length + 1;
+		const over = (d) => Math.abs(d.value) > this.cut;
+		const color = (d) => over(d) ? ctx.theme.critical : ctx.palette.color("Observations");
+		const base = axes.y(0), tip = (d) => ({
+			title: `Observation ${d.index + 1}`,
+			color: color(d),
+			rows: [[this.axisTitles().y, +d.value.toFixed(4)]]
+		});
+		const signed = measure === "dffits";
+		this.rules(ctx, "cutoff", cutoff ? [1, ...signed ? [-1] : []].map((sign) => ({
+			key: `${sign}`,
+			from: [0, sign * this.cut],
+			to: [count, sign * this.cut],
+			dash: "5 4"
+		})) : [], axes);
+		this.rules(ctx, "zero", signed ? [{
+			key: "zero",
+			from: [0, 0],
+			to: [count, 0],
+			strong: true
+		}] : [], axes);
+		const step = axes.x(1) - axes.x(0), thick = Math.max(2, step - 2);
+		const rects = ctx.marks("bars", "rect", marks === "bars" ? bars : [], (d) => d.index).attr("fill", color).attr("rx", Math.min(2, thick / 3));
+		const x = (d) => axes.x(d.slot) - thick / 2;
+		ctx.set(rects, {
+			x,
+			width: thick,
+			y: (d) => Math.min(base, axes.y(d.value)),
+			height: (d) => Math.abs(axes.y(d.value) - base)
+		}, {
+			x,
+			width: thick,
+			y: base,
+			height: 0
+		}, 4);
+		ctx.hover(rects, tip);
+		const stems = marks === "stems" ? bars : [];
+		const lines = ctx.marks("stems", "line", stems, (d) => d.index).attr("stroke", color).attr("stroke-width", 2).attr("stroke-linecap", "round");
+		ctx.set(lines, {
+			x1: (d) => axes.x(d.slot),
+			x2: (d) => axes.x(d.slot),
+			y1: base,
+			y2: (d) => axes.y(d.value)
+		}, {
+			x1: (d) => axes.x(d.slot),
+			x2: (d) => axes.x(d.slot),
+			y1: base,
+			y2: base
+		}, 4);
+		this.dots(ctx, "heads", stems, (d) => [axes.x(d.slot), axes.y(d.value)], color, tip, { key: (d) => d.index });
+		this.notes(ctx, "labels", bars.filter(over).sort((a, b) => Math.abs(b.value) - Math.abs(a.value)).slice(0, 3).map((d) => ({
+			key: `${d.index}`,
+			text: `${d.index + 1}`,
+			x: axes.x(d.slot),
+			y: axes.y(d.value) + (d.value < 0 ? 18 : -8),
+			anchor: "middle",
+			tone: "ink"
+		})));
+	}
+};
+export { CooksDistancePlot, InfluenceMarks, InfluenceMeasure, InfluenceOrder };