@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/demography/DemographyMarks.js

@@ -0,0 +1,31 @@
+// src/charts/demography/DemographyMarks.ts
+var round = (value) => +value.toFixed(2);
+/** Small drawing helpers shared by the demography charts. */
+var DemographyMarks = class {
+	static number(cell) {
+		const value = typeof cell === "string" && cell.trim() ? +cell : cell;
+		return typeof value === "number" && Number.isFinite(value) ? value : null;
+	}
+	static polygon(points) {
+		return points.length ? `M${points.map(([x, y]) => `${round(x)},${round(y)}`).join("L")}Z` : "";
+	}
+	static segment([x1, y1], [x2, y2]) {
+		return `M${round(x1)},${round(y1)}L${round(x2)},${round(y2)}`;
+	}
+	/** Short readable figure: three significant digits, thousands grouped. */
+	static figure(value) {
+		const digits = Math.abs(value) >= 100 ? 0 : Math.abs(value) >= 10 ? 1 : Math.abs(value) >= 1 ? 2 : 3;
+		return value.toLocaleString("en", { maximumFractionDigits: digits });
+	}
+	static captions(ctx, name, items) {
+		const text = ctx.marks(name, "text", items, (d) => d.key);
+		ctx.text(text);
+		const place = (d) => `translate(${round(d.x)},${round(d.y)})${d.rotate ? ` rotate(${d.rotate})` : ""}`;
+		return text.attr("fill", (d) => ({
+			ink: ctx.theme.ink,
+			secondary: ctx.theme.inkSecondary,
+			muted: ctx.theme.inkMuted
+		})[d.tone ?? "secondary"]).attr("font-size", (d) => d.size ?? 11).attr("font-weight", (d) => d.weight ?? null).attr("text-anchor", (d) => d.anchor ?? "middle").attr("stroke", (d) => d.halo ? ctx.theme.surface : null).attr("stroke-width", (d) => d.halo ? 3 : null).attr("paint-order", "stroke").attr("transform", place).style("pointer-events", "none").text((d) => d.text);
+	}
+};
+export { DemographyMarks };

package/dist/charts/demography/LexisCells.js

@@ -0,0 +1,143 @@
+import { DemographyMarks } from "./DemographyMarks.js";
+import { group, max, min, sum } from "d3";
+// src/charts/demography/LexisCells.ts
+var LexisCellKind = /* @__PURE__ */ function(LexisCellKind) {
+	LexisCellKind["None"] = "none";
+	LexisCellKind["AgePeriod"] = "age-period";
+	LexisCellKind["Triangle"] = "triangle";
+	LexisCellKind["PeriodCohort"] = "period-cohort";
+	LexisCellKind["AgeCohort"] = "age-cohort";
+	return LexisCellKind;
+}({});
+/** Reads Human Mortality Database style Lexis rows and folds them into squares, triangles or parallelograms. */
+var LexisCells = class LexisCells {
+	/** Rows without a cohort are split evenly between the two triangles of their square. */
+	static triangles(rows, columns) {
+		return rows.flatMap((row) => {
+			const read = DemographyMarks.number;
+			const year = read(row[columns.year]), age = read(row[columns.age]), value = read(row[columns.value]);
+			if (year === null || age === null || value === null) return [];
+			const exposure = read(row[columns.exposure]) ?? 0, cohort = read(row[columns.cohort]);
+			const lower = year - age, upper = lower - 1;
+			if (cohort === null) return [{
+				year,
+				age,
+				cohort: lower,
+				upper: false,
+				value: value / 2,
+				exposure: exposure / 2
+			}, {
+				year,
+				age,
+				cohort: upper,
+				upper: true,
+				value: value / 2,
+				exposure: exposure / 2
+			}];
+			return cohort === lower || cohort === upper ? [{
+				year,
+				age,
+				cohort,
+				upper: cohort === upper,
+				value,
+				exposure
+			}] : [];
+		});
+	}
+	static bounds(triangles) {
+		if (!triangles.length) return null;
+		return {
+			year0: min(triangles, (d) => d.year),
+			year1: max(triangles, (d) => d.year) + 1,
+			age0: min(triangles, (d) => d.age),
+			age1: max(triangles, (d) => d.age) + 1
+		};
+	}
+	/** Folds triangles into cells. A cell with only one of its two triangles keeps that triangle's outline. */
+	static fold(triangles, kind, per) {
+		if (kind === "none") return [];
+		return [...group(triangles, (d) => LexisCells.#key(d, kind))].map(([key, parts]) => {
+			const first = parts[0];
+			const half = parts.every((part) => part.upper === first.upper);
+			return {
+				key,
+				title: LexisCells.#title(first, kind),
+				polygon: half ? LexisCells.#triangle(first) : LexisCells.#whole(first, kind),
+				...LexisCells.total(parts, per)
+			};
+		});
+	}
+	/** Events over exposure, per `per`. With no exposure the values are taken as counts and added. */
+	static total(parts, per) {
+		const value = sum(parts, (d) => d.value), exposure = sum(parts, (d) => d.exposure);
+		return {
+			value,
+			exposure,
+			rate: exposure > 0 ? value / exposure * per : value
+		};
+	}
+	/** The diagonal strip one birth cohort sweeps through the plane, clipped to the plane's edges. */
+	static cohortBand(cohort, { year0, year1, age0, age1 }) {
+		const start = Math.max(year0, cohort + age0), end = Math.min(year1, cohort + age1 + 1);
+		if (start >= end) return [];
+		const stops = [...new Set([
+			start,
+			end,
+			cohort + age0 + 1,
+			cohort + age1
+		].filter((year) => year >= start && year <= end))].sort((a, b) => a - b);
+		const top = stops.map((year) => [year, Math.min(age1, year - cohort)]);
+		const bottom = stops.map((year) => [year, Math.max(age0, year - cohort - 1)]).reverse();
+		return [...top, ...bottom];
+	}
+	static #key({ year, age, cohort }, kind) {
+		if (kind === "age-period") return `${year}/${age}`;
+		if (kind === "period-cohort") return `${year}/${cohort}`;
+		if (kind === "age-cohort") return `${age}/${cohort}`;
+		return `${year}/${age}/${cohort}`;
+	}
+	static #title({ year, age, cohort }, kind) {
+		if (kind === "age-period") return `${year}, age ${age}`;
+		if (kind === "period-cohort") return `${year}, born ${cohort}`;
+		if (kind === "age-cohort") return `Age ${age}, born ${cohort}`;
+		return `${year}, age ${age}, born ${cohort}`;
+	}
+	static #triangle({ year, age, upper }) {
+		return upper ? [
+			[year, age],
+			[year + 1, age + 1],
+			[year, age + 1]
+		] : [
+			[year, age],
+			[year + 1, age],
+			[year + 1, age + 1]
+		];
+	}
+	static #whole({ year, age, cohort }, kind) {
+		if (kind === "period-cohort") {
+			const a = year - cohort;
+			return [
+				[year, a - 1],
+				[year + 1, a],
+				[year + 1, a + 1],
+				[year, a]
+			];
+		}
+		if (kind === "age-cohort") {
+			const y = cohort + age;
+			return [
+				[y, age],
+				[y + 1, age],
+				[y + 2, age + 1],
+				[y + 1, age + 1]
+			];
+		}
+		return [
+			[year, age],
+			[year + 1, age],
+			[year + 1, age + 1],
+			[year, age + 1]
+		];
+	}
+};
+export { LexisCellKind, LexisCells };

package/dist/charts/demography/LexisDiagram.js

@@ -0,0 +1,488 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { DemographyMarks } from "./DemographyMarks.js";
+import { LexisCellKind, LexisCells } from "./LexisCells.js";
+import { max, min, polygonArea, range } from "d3";
+// src/charts/demography/LexisDiagram.ts
+var LexisPlane = /* @__PURE__ */ function(LexisPlane) {
+	LexisPlane["Period"] = "period";
+	LexisPlane["Cohort"] = "cohort";
+	return LexisPlane;
+}({});
+var LexisGuides = /* @__PURE__ */ function(LexisGuides) {
+	LexisGuides["All"] = "all";
+	LexisGuides["Grid"] = "grid";
+	LexisGuides["Cohort"] = "cohort";
+	return LexisGuides;
+}({});
+var LexisFocus = /* @__PURE__ */ function(LexisFocus) {
+	LexisFocus["None"] = "none";
+	LexisFocus["Age"] = "age";
+	LexisFocus["Period"] = "period";
+	LexisFocus["Cohort"] = "cohort";
+	return LexisFocus;
+}({});
+var HEAD = 42;
+var FOOT = 36;
+var GUTTER = 42;
+var KEY = 80;
+var EDGE = 24;
+var STEPS = [
+	1,
+	2,
+	5,
+	10,
+	20,
+	50,
+	100
+];
+/** Maps vital events on the calendar-by-age plane, where every life runs at 45 degrees, to separate age, period and cohort effects. */
+var LexisDiagram = class extends Chart2D {
+	static meta = {
+		id: "lexis-diagram",
+		name: "Lexis diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Places age, period and birth cohort on one isometric plane, shading death rates by square, Lexis triangle or cohort parallelogram.",
+		tags: [
+			"demography",
+			"age period cohort",
+			"lifeline",
+			"mortality surface"
+		],
+		sample: (seed) => lexisSample(seed),
+		variants: {
+			cells: [
+				LexisCellKind.AgePeriod,
+				LexisCellKind.Triangle,
+				LexisCellKind.PeriodCohort,
+				LexisCellKind.AgeCohort,
+				LexisCellKind.None
+			],
+			guides: Object.values(LexisGuides),
+			focus: Object.values(LexisFocus),
+			plane: Object.values(LexisPlane),
+			lifelines: [false, true]
+		},
+		valid: (values) => !values.lifelines || values.focus === "none"
+	};
+	defaults() {
+		return {
+			year: "year",
+			age: "age",
+			cohort: "cohort",
+			value: "deaths",
+			exposure: "exposure",
+			per: 1e3,
+			valueLabel: "Deaths per 1,000",
+			scale: ScaleKind.Log,
+			birth: "birth",
+			entry: "entry",
+			exit: "exit",
+			event: "event",
+			cells: LexisCellKind.AgePeriod,
+			guides: "all",
+			focus: "none",
+			plane: "period",
+			lifelines: false
+		};
+	}
+	plotMargin() {
+		return {
+			top: 4,
+			right: 8,
+			bottom: 8,
+			left: 8
+		};
+	}
+	draw(ctx) {
+		const { data, cells, per } = this.options;
+		const triangles = LexisCells.triangles(data, this.options);
+		const lives = this.#lives();
+		const bounds = LexisCells.bounds(triangles) ?? this.#lifeBounds(lives);
+		if (!bounds) {
+			ctx.root.selectAll("*").remove();
+			return;
+		}
+		const fold = LexisCells.fold(triangles, cells, per);
+		const frame = this.#frame(ctx, bounds, fold.length > 0);
+		this.#drawCells(ctx, frame, fold);
+		this.#drawGuides(ctx, frame, bounds, fold.length > 0);
+		this.#drawAxes(ctx, frame, bounds);
+		this.#drawStrip(ctx, frame, bounds, triangles, fold.length > 0);
+		this.#drawLives(ctx, frame, bounds, lives);
+	}
+	#lives() {
+		const { data, birth, exit, entry, event } = this.options;
+		return data.flatMap((row, i) => {
+			const born = DemographyMarks.number(row[birth]), left = DemographyMarks.number(row[exit]);
+			if (born === null || left === null || left <= born) return [];
+			return [{
+				key: `life-${i}`,
+				row,
+				birth: born,
+				start: DemographyMarks.number(row[entry]) ?? born,
+				end: left,
+				closed: true,
+				event: Boolean(row[event])
+			}];
+		});
+	}
+	#lifeBounds(lives) {
+		if (!lives.length) return null;
+		return {
+			year0: Math.floor(min(lives, (d) => d.start)),
+			year1: Math.ceil(max(lives, (d) => d.end)),
+			age0: 0,
+			age1: Math.ceil(max(lives, (d) => d.end - d.birth))
+		};
+	}
+	/** One year spans the same length on both axes, so cohort lines hold their 45 degrees at any chart size. */
+	#frame({ plot }, { year0, year1, age0, age1 }, keyed) {
+		const cohort = this.options.plane === "cohort";
+		const x0 = cohort ? year0 - age1 : year0, x1 = cohort ? year1 - age0 : year1;
+		const room = plot.width - GUTTER - EDGE - (keyed ? KEY : 0);
+		const unit = Math.max(.5, Math.min(room / (x1 - x0), (plot.height - HEAD - FOOT) / (age1 - age0)));
+		const width = unit * (x1 - x0), height = unit * (age1 - age0);
+		const left = GUTTER + Math.max(0, (room - width) / 2), top = HEAD + Math.max(0, (plot.height - HEAD - FOOT - height) / 2);
+		const at = ([year, age]) => [left + unit * ((cohort ? year - age : year) - x0), top + unit * (age1 - age)];
+		return {
+			unit,
+			left,
+			top,
+			right: left + width,
+			bottom: top + height,
+			at
+		};
+	}
+	#drawCells(ctx, frame, fold) {
+		const tone = this.#tone(fold);
+		const gap = frame.unit >= 8 ? 1.5 : frame.unit >= 4 ? .75 : 0;
+		const shape = (cell) => DemographyMarks.polygon(inset(cell.polygon.map(frame.at), gap));
+		const { value, valueLabel, exposure } = this.options;
+		const paths = ctx.marks("cells", "path", fold, (d) => d.key).attr("fill", (d) => ctx.palette.sequential(tone(d.rate)));
+		ctx.set(paths, {
+			d: shape,
+			"fill-opacity": 1
+		}, { "fill-opacity": 0 });
+		ctx.hover(paths, (d) => ({
+			title: d.title,
+			rows: [
+				[value, DemographyMarks.figure(d.value)],
+				...d.exposure ? [[exposure, DemographyMarks.figure(d.exposure)]] : [],
+				[valueLabel, DemographyMarks.figure(d.rate)]
+			]
+		}));
+		this.#drawKey(ctx, frame, fold, tone);
+	}
+	#tone(fold) {
+		const low = min(fold, (d) => d.rate) ?? 0, high = max(fold, (d) => d.rate) ?? 1;
+		const kind = this.options.scale === ScaleKind.Log && low > 0 ? ScaleKind.Log : ScaleKind.Linear;
+		const scale = Scales.continuous(kind).domain([low, high > low ? high : low + 1]).range([0, 1]);
+		return (rate) => scale(rate);
+	}
+	#drawKey(ctx, frame, fold, tone) {
+		const shown = fold.length > 0 && ctx.plot.width >= 300;
+		const x = frame.right + EDGE + 18, height = Math.min(frame.bottom - frame.top, 180), top = frame.top + (frame.bottom - frame.top - height) / 2;
+		const steps = range(24).map((i) => i / 23);
+		const swatch = ctx.marks("key", "rect", shown ? steps : [], (d) => d).attr("fill", (d) => ctx.palette.sequential(d));
+		ctx.set(swatch, {
+			x,
+			y: (d) => top + (1 - d) * (height - height / 24),
+			width: 10,
+			height: height / 24 + .5
+		});
+		const rates = fold.map((d) => d.rate).sort((a, b) => a - b);
+		const low = rates[0] ?? 0, high = rates[rates.length - 1] ?? 0;
+		const middle = this.options.scale === ScaleKind.Log && low > 0 ? Math.sqrt(low * high) : (low + high) / 2;
+		const labels = shown ? [
+			high,
+			middle,
+			low
+		].map((value, i) => ({
+			key: `key-${i}`,
+			text: DemographyMarks.figure(value),
+			x: x + 14,
+			y: top + (1 - tone(value)) * height + 4 - (i === 0 ? -5 : i === 2 ? 5 : 0),
+			anchor: "start",
+			tone: "secondary"
+		})) : [];
+		if (shown) labels.push({
+			key: "key-title",
+			text: this.options.valueLabel,
+			x: x - 7,
+			y: top + height / 2,
+			rotate: -90
+		});
+		DemographyMarks.captions(ctx, "key-labels", labels);
+	}
+	#step(unit) {
+		return STEPS.find((step) => step * unit >= 34) ?? 200;
+	}
+	#rules({ year0, year1, age0, age1 }, step) {
+		const multiples = (from, to) => range(Math.ceil(from / step) * step, to + 1e-9, step);
+		return {
+			age: multiples(age0, age1).map((age) => ({
+				key: `a${age}`,
+				from: [year0, age],
+				to: [year1, age]
+			})),
+			period: multiples(year0, year1).map((year) => ({
+				key: `p${year}`,
+				from: [year, age0],
+				to: [year, age1]
+			})),
+			cohort: multiples(year0 - age1, year1 - age0).flatMap((cohort) => {
+				const start = Math.max(year0, cohort + age0), end = Math.min(year1, cohort + age1);
+				return start < end ? [{
+					key: `c${cohort}`,
+					from: [start, start - cohort],
+					to: [end, end - cohort]
+				}] : [];
+			})
+		};
+	}
+	#drawGuides(ctx, frame, bounds, shaded) {
+		const { guides } = this.options;
+		const { age, period, cohort } = this.#rules(bounds, this.#step(frame.unit));
+		const fine = !shaded && frame.unit >= 5 ? this.#rules(bounds, 1) : {
+			age: [],
+			period: [],
+			cohort: []
+		};
+		const grid = guides !== "cohort", diagonal = guides !== "grid";
+		const stroke = (name, rules, color, opacity) => {
+			const lines = ctx.marks(name, "path", rules, (d) => d.key).attr("stroke", color).attr("stroke-width", 1).attr("fill", "none").attr("stroke-opacity", opacity).style("pointer-events", "none");
+			ctx.set(lines, { d: (d) => DemographyMarks.segment(frame.at(d.from), frame.at(d.to)) });
+		};
+		const edge = ctx.marks("plane-edge", "path", [0], (d) => d).attr("stroke", ctx.theme.axis).attr("fill", "none");
+		const { year0, year1, age0, age1 } = bounds;
+		ctx.set(edge, { d: DemographyMarks.polygon([
+			[year0, age0],
+			[year1, age0],
+			[year1, age1],
+			[year0, age1]
+		].map(frame.at)) });
+		stroke("fine-grid", grid ? [...fine.age, ...fine.period] : [], ctx.theme.grid, null);
+		stroke("fine-cohort", diagonal ? fine.cohort : [], ctx.theme.grid, null);
+		const major = shaded ? ctx.theme.ink : ctx.theme.axis, opacity = shaded ? .32 : null;
+		stroke("grid", grid ? [...age, ...period] : [], major, opacity);
+		stroke("cohort", diagonal ? cohort : [], major, opacity);
+	}
+	#drawAxes(ctx, frame, bounds) {
+		const { guides, plane } = this.options;
+		const onPeriod = plane === "period";
+		const step = this.#step(frame.unit);
+		const { age, period, cohort } = this.#rules(bounds, step);
+		const base = ctx.marks("axis-line", "path", [0], (d) => d).attr("stroke", ctx.theme.axis).attr("fill", "none");
+		ctx.set(base, { d: `M${frame.left},${frame.top}V${frame.bottom}H${frame.right}` });
+		const across = onPeriod ? period.map((d) => ({
+			key: d.key,
+			text: String(d.from[0]),
+			x: frame.at(d.from)[0],
+			y: frame.bottom + 15
+		})) : range(Math.ceil((bounds.year0 - bounds.age1) / step) * step, bounds.year1 - bounds.age0 + 1e-9, step).map((birth) => ({
+			key: `b${birth}`,
+			text: String(birth),
+			x: frame.at([birth, 0])[0],
+			y: frame.bottom + 15
+		}));
+		const up = age.map((d) => ({
+			key: d.key,
+			text: String(d.from[1]),
+			x: frame.left - 6,
+			y: frame.at(d.from)[1] + 4,
+			anchor: "end"
+		}));
+		const titles = [{
+			key: "x",
+			text: onPeriod ? "Calendar year" : "Year of birth",
+			x: (frame.left + frame.right) / 2,
+			y: frame.bottom + 31
+		}, {
+			key: "y",
+			text: "Exact age",
+			x: frame.left - 32,
+			y: (frame.top + frame.bottom) / 2,
+			rotate: -90
+		}];
+		const third = (onPeriod ? guides !== "grid" : guides !== "cohort") ? onPeriod ? cohort : period : [];
+		const ends = third.map((d) => {
+			const [x, y] = frame.at(d.to);
+			return {
+				key: d.key,
+				text: String(onPeriod ? d.from[0] - d.from[1] : d.from[0]),
+				x: x + (onPeriod ? 3 : -3),
+				y: y - 3,
+				anchor: onPeriod ? "start" : "end",
+				rotate: onPeriod ? -45 : 45,
+				tone: "muted"
+			};
+		});
+		if (third.length) titles.push({
+			key: "third",
+			text: onPeriod ? "Diagonals: year of birth" : "Diagonals: calendar year",
+			x: onPeriod ? frame.left : frame.right,
+			y: frame.top - 32,
+			anchor: onPeriod ? "start" : "end",
+			tone: "muted"
+		});
+		DemographyMarks.captions(ctx, "axis-across", across);
+		DemographyMarks.captions(ctx, "axis-up", up);
+		DemographyMarks.captions(ctx, "axis-ends", ends);
+		DemographyMarks.captions(ctx, "axis-titles", titles);
+	}
+	#strip(bounds, triangles) {
+		const { focus, focusAt } = this.options;
+		const { year0, year1, age0, age1 } = bounds;
+		if (focus === "age") {
+			const age = focusAt ?? Math.floor((age0 + age1) / 2);
+			return {
+				label: `Age ${age}`,
+				polygon: [
+					[year0, age],
+					[year1, age],
+					[year1, age + 1],
+					[year0, age + 1]
+				],
+				along: [[year0, age + .5], [year1, age + .5]],
+				parts: triangles.filter((d) => d.age === age)
+			};
+		}
+		if (focus === "period") {
+			const year = focusAt ?? Math.floor((year0 + year1) / 2);
+			return {
+				label: `Year ${year}`,
+				polygon: [
+					[year, age0],
+					[year + 1, age0],
+					[year + 1, age1],
+					[year, age1]
+				],
+				along: [[year + .5, age0], [year + .5, age1]],
+				parts: triangles.filter((d) => d.year === year)
+			};
+		}
+		if (focus === "cohort") {
+			const cohort = focusAt ?? Math.floor((year0 - age1 + year1 - age0) / 2);
+			const start = Math.max(year0, cohort + age0 + .5), end = Math.min(year1, cohort + age1 + .5);
+			return {
+				label: `Born ${cohort}`,
+				polygon: LexisCells.cohortBand(cohort, bounds),
+				along: [[start, start - cohort - .5], [end, end - cohort - .5]],
+				parts: triangles.filter((d) => d.cohort === cohort)
+			};
+		}
+		return null;
+	}
+	#drawStrip(ctx, frame, bounds, triangles, shaded) {
+		const strip = this.#strip(bounds, triangles);
+		const { per, valueLabel, value } = this.options;
+		const shown = strip ? [strip] : [];
+		const paths = ctx.marks("strip", "path", shown, (d) => d.label).attr("fill", shaded ? "none" : (d) => ctx.palette.color(d.label)).attr("fill-opacity", .28).attr("stroke", ctx.theme.ink).attr("stroke-width", 2).attr("stroke-linejoin", "round");
+		ctx.set(paths, { d: (d) => DemographyMarks.polygon(d.polygon.map(frame.at)) });
+		ctx.hover(paths, (d) => {
+			const total = LexisCells.total(d.parts, per);
+			return {
+				title: d.label,
+				rows: [[value, DemographyMarks.figure(total.value)], [valueLabel, DemographyMarks.figure(total.rate)]]
+			};
+		});
+		const labels = shown.map((d) => {
+			const [x0, y0] = frame.at(d.along[0]), [x1, y1] = frame.at(d.along[1]);
+			const angle = Math.atan2(y1 - y0, x1 - x0) * 180 / Math.PI;
+			return {
+				key: d.label,
+				text: d.label,
+				x: x0 + (x1 - x0) * .3,
+				y: y0 + (y1 - y0) * .3,
+				rotate: angle > 90 ? angle - 180 : angle < -90 ? angle + 180 : angle,
+				tone: "ink",
+				weight: 600,
+				halo: true
+			};
+		});
+		DemographyMarks.captions(ctx, "strip-label", labels).attr("dy", "0.35em");
+	}
+	#drawLives(ctx, frame, { year0, year1, age0, age1 }, lives) {
+		const clipped = !this.options.lifelines ? [] : lives.flatMap((life) => {
+			const start = Math.max(life.start, year0, life.birth + age0), end = Math.min(life.end, year1, life.birth + age1);
+			return start < end ? [{
+				...life,
+				start,
+				end,
+				closed: end === life.end
+			}] : [];
+		});
+		const shape = (d) => DemographyMarks.segment(frame.at([d.start, d.start - d.birth]), frame.at([d.end, d.end - d.birth]));
+		const halos = ctx.marks("life-halo", "path", clipped, (d) => d.key).attr("stroke", ctx.theme.surface).attr("stroke-width", 4).attr("fill", "none").style("pointer-events", "none");
+		ctx.set(halos, { d: shape });
+		const lines = ctx.marks("lives", "path", clipped, (d) => d.key).attr("stroke", ctx.theme.ink).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("fill", "none");
+		ctx.set(lines, { d: shape });
+		ctx.drawOn(lines);
+		const tip = (d) => ({
+			title: `Born ${Math.floor(d.birth)}`,
+			rows: [["Exit age", DemographyMarks.figure(d.end - d.birth)], ["Outcome", d.event ? "Event" : "Censored"]]
+		});
+		ctx.hover(lines, tip);
+		const ends = ctx.marks("life-ends", "circle", clipped.filter((d) => d.closed), (d) => d.key).attr("fill", (d) => d.event ? ctx.theme.ink : ctx.theme.surface).attr("stroke", (d) => d.event ? ctx.theme.surface : ctx.theme.ink).attr("stroke-width", 2);
+		ctx.set(ends, {
+			cx: (d) => frame.at([d.end, d.end - d.birth])[0],
+			cy: (d) => frame.at([d.end, d.end - d.birth])[1],
+			r: 4.5
+		});
+		ctx.hover(ends, tip);
+	}
+};
+/** Offsets a convex cell's edges inward by half the gap, so neighbours stay apart without a border. */
+function inset(points, gap) {
+	if (!gap || points.length < 3) return [...points];
+	const turn = polygonArea(points) > 0 ? -1 : 1;
+	const normal = ([ax, ay], [bx, by]) => {
+		const length = Math.hypot(bx - ax, by - ay) || 1;
+		return [-turn * (by - ay) / length, turn * (bx - ax) / length];
+	};
+	return points.map((point, i) => {
+		const [ax, ay] = normal(points[(i + points.length - 1) % points.length], point), [bx, by] = normal(point, points[(i + 1) % points.length]);
+		const miter = gap / 2 / (1 + ax * bx + ay * by);
+		return [point[0] + (ax + bx) * miter, point[1] + (ay + by) * miter];
+	});
+}
+var YEAR = 1976;
+var AGE = 64;
+var YEARS = 30;
+var AGES = 18;
+/**
+* Period-by-age mortality in Lexis triangles: Gompertz ageing, steady period decline and a raised
+* 1918 birth cohort, with SampleData's matrix as the residual, plus a dozen lifelines from its points.
+*/
+function lexisSample(seed) {
+	const { values } = SampleData.matrix(seed, AGES, YEARS);
+	const hazard = (year, age, cohort) => .018 * Math.exp(.09 * (age - AGE)) * Math.exp(-.014 * (year - YEAR)) * (Math.abs(cohort - 1918) <= 1 ? 1.25 : 1);
+	const rows = values.flatMap((line, a) => line.flatMap((noise, y) => {
+		const year = YEAR + y, age = AGE + a;
+		return [year - age, year - age - 1].map((cohort, upper) => {
+			const exposure = Math.round(4e4 * Math.exp(-.035 * a));
+			return {
+				year,
+				age,
+				cohort,
+				deaths: Math.round(exposure * hazard(year, age + (upper ? .67 : .33), cohort) * Math.exp(.04 * noise)),
+				exposure
+			};
+		});
+	}));
+	const lives = SampleData.points(seed, 12).map(({ x, y, size }) => {
+		const birth = +(1896 + x * .8).toFixed(2), died = birth + 64 + y * .4;
+		return {
+			birth,
+			exit: +Math.min(died, 2005.5).toFixed(2),
+			event: died < 2005.5 && size > 8 ? 1 : 0
+		};
+	});
+	return [...rows, ...lives];
+}
+export { LexisDiagram, LexisFocus, LexisGuides, LexisPlane };