@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/lifescience/RamachandranSamples.js

@@ -0,0 +1,235 @@
+import { randomLcg, randomNormal, randomUniform } from "d3";
+// src/charts/lifescience/RamachandranSamples.ts
+var GENERAL_RESIDUES = [
+	"ALA",
+	"LEU",
+	"GLU",
+	"LYS",
+	"SER",
+	"ASP",
+	"THR",
+	"ARG",
+	"ASN",
+	"PHE"
+];
+/** Alpha helix, beta strand, polyproline II and left-handed helix, the populations any protein shows. */
+var GENERAL = [
+	[
+		-63,
+		-43,
+		6,
+		.5
+	],
+	[
+		-118,
+		132,
+		13,
+		.25
+	],
+	[
+		-68,
+		146,
+		9,
+		.18
+	],
+	[
+		58,
+		42,
+		7,
+		.07
+	]
+];
+var GLYCINE = [
+	[
+		82,
+		8,
+		9,
+		.35
+	],
+	[
+		-82,
+		-6,
+		9,
+		.2
+	],
+	[
+		-170,
+		175,
+		9,
+		.25
+	],
+	[
+		90,
+		-172,
+		9,
+		.2
+	]
+];
+var TRANS_PROLINE = [[
+	-63,
+	-33,
+	6,
+	.55
+], [
+	-66,
+	146,
+	7,
+	.45
+]];
+var CIS_PROLINE = [[
+	-75,
+	158,
+	6,
+	.6
+], [
+	-85,
+	0,
+	7,
+	.4
+]];
+var PRE_PROLINE = [
+	[
+		-65,
+		145,
+		9,
+		.55
+	],
+	[
+		-120,
+		140,
+		10,
+		.3
+	],
+	[
+		-62,
+		-38,
+		6,
+		.15
+	]
+];
+var ILE_VAL = [[
+	-115,
+	128,
+	11,
+	.6
+], [
+	-64,
+	-43,
+	5,
+	.4
+]];
+/** Each lands outside the map for its class, so outliers exist to draw on every panel. */
+var PLANTED = [
+	[
+		"ALA",
+		"SER",
+		2,
+		-120,
+		179
+	],
+	[
+		"GLY",
+		"SER",
+		-30,
+		-140,
+		180
+	],
+	[
+		"PRO",
+		"SER",
+		62,
+		30,
+		178
+	],
+	[
+		"PRO",
+		"SER",
+		60,
+		-120,
+		2
+	],
+	[
+		"LEU",
+		"PRO",
+		75,
+		-85,
+		180
+	],
+	[
+		"VAL",
+		"SER",
+		60,
+		100,
+		180
+	]
+];
+/** Synthetic backbone torsions drawn around textbook conformations. They are not measured from any structure. */
+var RamachandranSamples = class {
+	static protein(seed, count = 220) {
+		const source = randomLcg(seed * .6180339887 % 1);
+		const pick = randomUniform.source(source)(0, 1), normal = randomNormal.source(source)(0, 1);
+		const within = (clusters) => {
+			let draw = pick();
+			const cluster = clusters.find((item) => (draw -= item[3]) <= 0) ?? clusters[0];
+			return [cluster[0] + normal() * cluster[2], cluster[1] + normal() * cluster[2]];
+		};
+		const residue = (i) => {
+			const roll = pick();
+			if (roll < .09) return {
+				name: "GLY",
+				next: "SER",
+				spot: within(GLYCINE),
+				omega: 180
+			};
+			if (roll < .14) return {
+				name: "PRO",
+				next: "SER",
+				spot: within(TRANS_PROLINE),
+				omega: 179
+			};
+			if (roll < .17) return {
+				name: "PRO",
+				next: "SER",
+				spot: within(CIS_PROLINE),
+				omega: 3
+			};
+			if (roll < .23) return {
+				name: "ALA",
+				next: "PRO",
+				spot: within(PRE_PROLINE),
+				omega: 180
+			};
+			if (roll < .33) return {
+				name: roll < .28 ? "ILE" : "VAL",
+				next: "SER",
+				spot: within(ILE_VAL),
+				omega: 180
+			};
+			return {
+				name: GENERAL_RESIDUES[i % GENERAL_RESIDUES.length],
+				next: "SER",
+				spot: within(GENERAL),
+				omega: 180
+			};
+		};
+		return [...Array.from({ length: count }, (_, i) => {
+			const { name, next, spot, omega } = residue(i);
+			return {
+				label: `${name} ${i + 1}`,
+				residue: name,
+				nextResidue: next,
+				phi: +spot[0].toFixed(1),
+				psi: +spot[1].toFixed(1),
+				omega
+			};
+		}), ...PLANTED.map(([name, next, phi, psi, omega], i) => ({
+			label: `${name} ${count + i + 1}`,
+			residue: name,
+			nextResidue: next,
+			phi,
+			psi,
+			omega
+		}))];
+	}
+};
+export { RamachandranSamples };

package/dist/charts/lifescience/index.js

@@ -0,0 +1,25 @@
+import { LoessFit } from "./LoessFit.js";
+import { MaPlotSamples } from "./MaPlotSamples.js";
+import { MaMarks, MaNormalization, MaPlot, MaSource } from "./MaPlot.js";
+import { OncoAlteration, OncoGlyph, OncoLayer } from "./OncoGlyph.js";
+import { OncoPrintMatrix, OncoSort } from "./OncoPrintMatrix.js";
+import { OncoPrintSamples } from "./OncoPrintSamples.js";
+import { OncoBars, OncoPrint, OncoTracks, OncoUnaltered } from "./OncoPrint.js";
+import { PedigreeCaption, PedigreeCarrierMark, PedigreeSex } from "./pedigreeEnums.js";
+import { PedigreeLayout } from "./PedigreeLayout.js";
+import { PedigreeRows } from "./PedigreeRows.js";
+import { PedigreeSamples } from "./PedigreeSamples.js";
+import { PedigreeSymbol } from "./PedigreeSymbol.js";
+import { PedigreeChart } from "./PedigreeChart.js";
+import { RamachandranClass, RamachandranPanel, RamachandranRegionStyle, RamachandranVerdict } from "./ramachandranEnums.js";
+import { RamachandranRegions } from "./RamachandranRegions.js";
+import { RamachandranSamples } from "./RamachandranSamples.js";
+import { RamachandranPlot } from "./RamachandranPlot.js";
+// src/charts/lifescience/index.ts
+var lifescienceCatalog = [
+	MaPlot,
+	OncoPrint,
+	PedigreeChart,
+	RamachandranPlot
+];
+export { LoessFit, MaMarks, MaNormalization, MaPlot, MaPlotSamples, MaSource, OncoAlteration, OncoBars, OncoGlyph, OncoLayer, OncoPrint, OncoPrintMatrix, OncoPrintSamples, OncoSort, OncoTracks, OncoUnaltered, PedigreeCaption, PedigreeCarrierMark, PedigreeChart, PedigreeLayout, PedigreeRows, PedigreeSamples, PedigreeSex, PedigreeSymbol, RamachandranClass, RamachandranPanel, RamachandranPlot, RamachandranRegionStyle, RamachandranRegions, RamachandranSamples, RamachandranVerdict, lifescienceCatalog };

package/dist/charts/lifescience/pedigreeEnums.js

@@ -0,0 +1,21 @@
+// src/charts/lifescience/pedigreeEnums.ts
+var PedigreeSex = /* @__PURE__ */ function(PedigreeSex) {
+	PedigreeSex["Male"] = "male";
+	PedigreeSex["Female"] = "female";
+	PedigreeSex["Unknown"] = "unknown";
+	return PedigreeSex;
+}({});
+/** A heterozygote: the central dot of the NSGC standard, or the half-shaded symbol common in textbooks. */
+var PedigreeCarrierMark = /* @__PURE__ */ function(PedigreeCarrierMark) {
+	PedigreeCarrierMark["Dot"] = "dot";
+	PedigreeCarrierMark["HalfFill"] = "half-fill";
+	return PedigreeCarrierMark;
+}({});
+/** What is written under each symbol. */
+var PedigreeCaption = /* @__PURE__ */ function(PedigreeCaption) {
+	PedigreeCaption["Number"] = "number";
+	PedigreeCaption["NumberAndName"] = "number-and-name";
+	PedigreeCaption["None"] = "none";
+	return PedigreeCaption;
+}({});
+export { PedigreeCaption, PedigreeCarrierMark, PedigreeSex };

package/dist/charts/lifescience/ramachandranEnums.js

@@ -0,0 +1,34 @@
+// src/charts/lifescience/ramachandranEnums.ts
+/** MolProbity's six Top8000 reference classes. */
+var RamachandranClass = /* @__PURE__ */ function(RamachandranClass) {
+	RamachandranClass["General"] = "general";
+	RamachandranClass["Glycine"] = "glycine";
+	RamachandranClass["TransProline"] = "trans-proline";
+	RamachandranClass["CisProline"] = "cis-proline";
+	RamachandranClass["PreProline"] = "pre-proline";
+	RamachandranClass["IleVal"] = "ile-val";
+	return RamachandranClass;
+}({});
+/** Which reference map a plot shows: every residue on the general map, or one class on its own. */
+var RamachandranPanel = /* @__PURE__ */ function(RamachandranPanel) {
+	RamachandranPanel["All"] = "all";
+	RamachandranPanel["General"] = "general";
+	RamachandranPanel["Glycine"] = "glycine";
+	RamachandranPanel["TransProline"] = "trans-proline";
+	RamachandranPanel["CisProline"] = "cis-proline";
+	RamachandranPanel["PreProline"] = "pre-proline";
+	RamachandranPanel["IleVal"] = "ile-val";
+	return RamachandranPanel;
+}({});
+var RamachandranRegionStyle = /* @__PURE__ */ function(RamachandranRegionStyle) {
+	RamachandranRegionStyle["Filled"] = "filled";
+	RamachandranRegionStyle["Contour"] = "contour";
+	return RamachandranRegionStyle;
+}({});
+var RamachandranVerdict = /* @__PURE__ */ function(RamachandranVerdict) {
+	RamachandranVerdict["Favoured"] = "favoured";
+	RamachandranVerdict["Allowed"] = "allowed";
+	RamachandranVerdict["Outlier"] = "outlier";
+	return RamachandranVerdict;
+}({});
+export { RamachandranClass, RamachandranPanel, RamachandranRegionStyle, RamachandranVerdict };

package/dist/charts/linesareas/AreaChart.js

@@ -0,0 +1,76 @@
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { AreaBaseline, LineMarkers } from "./LineEnums.js";
+import { TrendChart } from "./TrendChart.js";
+import { mean } from "d3";
+// src/charts/linesareas/AreaChart.ts
+/** A line with its volume filled, for one or two series whose magnitude matters. Stack with `StackedAreaChart` for parts of a whole. */
+var AreaChart = class extends TrendChart {
+	static meta = {
+		id: "area",
+		name: "Area chart",
+		family: ChartFamily.Trend,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Fills under a line to stress the magnitude of a value over time, from zero or around a reference level.",
+		tags: [
+			"trend",
+			"volume",
+			"mountain"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 40, 2),
+		variants: {
+			curve: [
+				CurveKind.Monotone,
+				CurveKind.Linear,
+				CurveKind.StepAfter,
+				CurveKind.Natural,
+				CurveKind.Basis
+			],
+			baseline: [
+				AreaBaseline.Zero,
+				AreaBaseline.Mean,
+				AreaBaseline.First
+			],
+			outline: [true, false],
+			markers: [
+				LineMarkers.None,
+				LineMarkers.Ends,
+				LineMarkers.Extrema
+			]
+		},
+		valid: ({ outline, markers }) => outline === true || markers === LineMarkers.None
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			baseline: AreaBaseline.Zero,
+			outline: true,
+			markers: LineMarkers.None
+		};
+	}
+	get zeroBased() {
+		return this.options.baseline === AreaBaseline.Zero;
+	}
+	level(series) {
+		const known = series.points.filter(this.drawn);
+		if (this.options.baseline === AreaBaseline.Zero) return 0;
+		return this.options.baseline === AreaBaseline.Mean ? mean(known, (p) => p.y) ?? 0 : known[0]?.y ?? 0;
+	}
+	plotMarks(ctx, axes) {
+		const series = this.view;
+		const base = (s) => axes.y(this.level(s)) ?? ctx.plot.height;
+		const fills = ctx.marks("fills", "path", series, (s) => s.key).attr("fill", (s) => ctx.palette.color(s.key)).attr("fill-opacity", this.options.outline ? series.length > 1 ? .22 : .3 : .45);
+		ctx.set(fills, { d: (s) => this.areaPath(axes, base(s))(s.points) }, { d: (s) => this.flatPath(axes, base(s))(s.points) });
+		this.strokes(ctx, "lines", this.options.outline ? series : [], axes);
+		this.rules(ctx, axes, series, base);
+		this.markers(ctx, series, axes, this.options.markers);
+		this.hoverColumns(ctx, axes, series);
+	}
+	rules(ctx, axes, series, base) {
+		const shown = this.options.baseline === AreaBaseline.Zero ? [] : series;
+		const width = axes.x.range?.()[1] ?? ctx.plot.width;
+		ctx.marks("baselines", "line", shown, (s) => s.key).attr("stroke", ctx.theme.axis).attr("stroke-width", 1).attr("stroke-dasharray", "3 3").attr("x1", 0).attr("x2", width).attr("y1", base).attr("y2", base);
+	}
+};
+export { AreaChart };

package/dist/charts/linesareas/BumpChart.js

@@ -0,0 +1,155 @@
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { BumpDirection, BumpStops, BumpWidth, SlopeLabels } from "./LineEnums.js";
+import { TrendChart } from "./TrendChart.js";
+import { TrendLabels } from "./TrendLabels.js";
+import { TrendMath } from "./TrendMath.js";
+import { area, range, scaleLinear } from "d3";
+// src/charts/linesareas/BumpChart.ts
+var ROOM = 84;
+/** Rank over time: who overtook whom. Ties keep first-seen order; values that are missing leave a gap. */
+var BumpChart = class extends TrendChart {
+	static meta = {
+		id: "bump",
+		name: "Bump chart",
+		family: ChartFamily.Trend,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots the rank of each entity at each period to reveal overtakes rather than the gaps between values.",
+		tags: [
+			"rank",
+			"ranking over time",
+			"league table"
+		],
+		sample: (seed) => TrendMath.restart(SampleData.timeSeries(seed, 64, 6), 200).filter((_, i) => i % 64 % 9 === 0),
+		variants: {
+			curve: [
+				CurveKind.Bump,
+				CurveKind.Linear,
+				CurveKind.Monotone
+			],
+			direction: [BumpDirection.TopFirst, BumpDirection.BottomFirst],
+			labels: [SlopeLabels.Both, SlopeLabels.Right],
+			stops: [
+				BumpStops.Dots,
+				BumpStops.Ranks,
+				BumpStops.None
+			],
+			thickness: [BumpWidth.Uniform, BumpWidth.Value]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			curve: CurveKind.Bump,
+			direction: BumpDirection.TopFirst,
+			labels: SlopeLabels.Both,
+			stops: BumpStops.Dots,
+			thickness: BumpWidth.Uniform,
+			grid: false
+		};
+	}
+	get direct() {
+		return true;
+	}
+	startRoom() {
+		return this.options.labels === SlopeLabels.Both ? TrendLabels.room(this.view.map((s) => s.key), ROOM) : 0;
+	}
+	yTicks() {
+		return this.view.length;
+	}
+	shape(table) {
+		const ranks = /* @__PURE__ */ new Map();
+		const lookups = table.series.map((s) => ({
+			key: s.key,
+			values: TrendMath.byOrder(s)
+		}));
+		for (const slot of table.xs) {
+			const present = lookups.flatMap(({ key, values }) => {
+				const value = values.get(slot.order);
+				return value === null || value === void 0 ? [] : [{
+					key,
+					value
+				}];
+			}).sort((a, b) => b.value - a.value);
+			ranks.set(slot.order, new Map(present.map((item, i) => [item.key, i + 1])));
+		}
+		return table.series.map((s) => ({
+			key: s.key,
+			points: s.points.map((p) => ({
+				...p,
+				raw: p.y,
+				y: p.y === null ? null : ranks.get(p.order).get(s.key)
+			}))
+		}));
+	}
+	yAxis(height) {
+		const count = Math.max(1, this.view.length);
+		const span = this.options.direction === BumpDirection.TopFirst ? [0, height] : [height, 0];
+		const every = Math.ceil(count / Math.max(1, Math.floor(height / 16)));
+		return Object.assign(scaleLinear([.5, count + .5], span), { ticks: () => range(1, count + 1, every) });
+	}
+	ribbon(ctx, series, axes) {
+		const top = Math.max(1, ...series.flatMap((s) => s.points.map((p) => Math.abs(p.raw ?? 0))));
+		const half = ctx.plot.height / Math.max(1, this.view.length) * .4;
+		const thick = (p) => Math.max(1, Math.abs(p.raw ?? 0) / top * half);
+		const shape = area().defined(this.drawn).x((p) => this.px(axes, p)).y0((p) => this.py(axes, p) + thick(p)).y1((p) => this.py(axes, p) - thick(p)).curve(this.curveOf());
+		const flat = area().defined(this.drawn).x((p) => this.px(axes, p)).y((p) => this.py(axes, p)).curve(this.curveOf());
+		const fills = ctx.marks("ribbons", "path", series, (s) => s.key).attr("fill", (s) => ctx.palette.color(s.key));
+		ctx.set(fills, { d: (s) => shape(s.points) ?? "" }, { d: (s) => flat(s.points) ?? "" });
+	}
+	stopMarks(ctx, series, axes) {
+		const { stops } = this.options;
+		const items = stops === BumpStops.None ? [] : series.flatMap((s) => s.points.filter(this.drawn).map((p) => ({
+			key: `${s.key}/${p.order}`,
+			x: this.px(axes, p),
+			y: this.py(axes, p),
+			color: ctx.palette.color(s.key),
+			rank: p.y
+		})));
+		const numbered = stops === BumpStops.Ranks;
+		const radius = numbered ? Math.max(5, Math.min(9, ctx.plot.height / Math.max(1, this.view.length) / 2 - 1)) : 5;
+		const marks = this.dots(ctx, "stops", items, ctx.root, radius);
+		if (numbered) marks.attr("stroke-width", 0);
+		const numbers = ctx.marks("stop-ranks", "text", numbered ? items : [], (d) => d.key).attr("text-anchor", "middle").attr("dy", ".34em").attr("font-size", 10).attr("font-weight", 600).attr("font-family", ctx.theme.fontFamily).attr("fill", (d) => ctx.palette.inkOn(d.color)).text((d) => d.rank);
+		ctx.set(numbers, {
+			x: (d) => d.x,
+			y: (d) => d.y
+		}, {
+			x: (d) => d.x,
+			y: (d) => d.y
+		});
+	}
+	startLabels(ctx, series, axes) {
+		const room = this.startRoom();
+		const items = room ? series.flatMap((s) => {
+			const first = s.points.find(this.drawn);
+			return first ? [{
+				key: s.key,
+				x: this.px(axes, first),
+				y: this.py(axes, first)
+			}] : [];
+		}) : [];
+		const placed = TrendLabels.dodge(items, ctx.plot.height);
+		const labels = ctx.text(ctx.marks("start-labels", "text", placed, (d) => d.key)).attr("text-anchor", "end").attr("dy", ".32em").text((d) => TrendLabels.fit(d.key, room - 12));
+		ctx.set(labels, {
+			x: (d) => d.x - 10,
+			y: (d) => d.at
+		}, {
+			x: (d) => d.x - 10,
+			y: (d) => d.at
+		});
+	}
+	plotMarks(ctx, axes) {
+		const series = this.view;
+		const ribbons = this.options.thickness === BumpWidth.Value;
+		this.ribbon(ctx, ribbons ? series : [], axes);
+		this.strokes(ctx, "lines", ribbons ? [] : series, axes, Scales.curve(this.options.curve));
+		this.stopMarks(ctx, series, axes);
+		this.startLabels(ctx, series, axes);
+		this.endLabels(ctx, series, axes);
+		this.hoverColumns(ctx, axes, series);
+	}
+};
+export { BumpChart };

package/dist/charts/linesareas/CumulativeLine.js

@@ -0,0 +1,115 @@
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { CumulativeReset, CumulativeUnit } from "./LineEnums.js";
+import { TrendChart } from "./TrendChart.js";
+import { utcMonday, utcMonth } from "d3";
+// src/charts/linesareas/CumulativeLine.ts
+/** Running total of a measure. Use it for progress against a target, burn-up, or month-to-date revenue. */
+var CumulativeLine = class extends TrendChart {
+	static meta = {
+		id: "cumulative-line",
+		name: "Cumulative line",
+		family: ChartFamily.Trend,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Accumulates a value along x to show running totals, pace against an even rate, or period-to-date progress.",
+		tags: [
+			"running total",
+			"burn-up",
+			"year to date"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 60, 2),
+		variants: {
+			curve: [
+				CurveKind.Linear,
+				CurveKind.StepAfter,
+				CurveKind.Monotone
+			],
+			unit: [CumulativeUnit.Absolute, CumulativeUnit.Share],
+			reset: [
+				CumulativeReset.Never,
+				CumulativeReset.Weekly,
+				CumulativeReset.Monthly
+			],
+			pace: [false, true],
+			fill: [false, true]
+		},
+		valid: ({ unit, reset, pace }) => reset === CumulativeReset.Never || unit === CumulativeUnit.Absolute && !pace
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			curve: CurveKind.Linear,
+			unit: CumulativeUnit.Absolute,
+			reset: CumulativeReset.Never,
+			pace: false,
+			fill: false
+		};
+	}
+	get zeroBased() {
+		return true;
+	}
+	period(point) {
+		const { reset } = this.options;
+		if (!(point.x instanceof Date) || reset === CumulativeReset.Never) return 0;
+		return +(reset === CumulativeReset.Weekly ? utcMonday : utcMonth).floor(point.x);
+	}
+	shape(table) {
+		return table.series.map((s) => {
+			let total = 0, period = NaN;
+			const running = s.points.map((point) => {
+				const at = this.period(point);
+				if (at !== period) {
+					period = at;
+					total = 0;
+				}
+				total += point.y ?? 0;
+				return {
+					...point,
+					y: total,
+					raw: total
+				};
+			});
+			const final = running.at(-1)?.y || 1;
+			return {
+				key: s.key,
+				points: this.options.unit === CumulativeUnit.Share ? running.map((p) => ({
+					...p,
+					y: p.y / final * 100
+				})) : running
+			};
+		});
+	}
+	plotMarks(ctx, axes) {
+		const { fill, pace, reset } = this.options;
+		const series = this.view;
+		const base = axes.y(0) ?? ctx.plot.height;
+		const runs = series.flatMap((s) => {
+			const parts = /* @__PURE__ */ new Map();
+			for (const point of s.points) {
+				const period = this.period(point);
+				(parts.get(period) ?? parts.set(period, []).get(period)).push(point);
+			}
+			return [...parts].map(([period, points]) => ({
+				key: `${s.key}/${period}`,
+				owner: s.key,
+				points
+			}));
+		});
+		const color = (s) => ctx.palette.color(s.owner);
+		const shape = this.areaPath(axes, base);
+		const fills = ctx.marks("fills", "path", fill ? runs : [], (s) => s.key).attr("fill", color).attr("fill-opacity", .2);
+		ctx.set(fills, { d: (s) => shape(s.points) }, { d: (s) => this.flatPath(axes, base)(s.points) });
+		this.strokes(ctx, "lines", runs, axes, this.curveOf(), color);
+		const paced = pace && reset === CumulativeReset.Never ? series.map((s) => ({
+			key: s.key,
+			points: [s.points[0], s.points.at(-1)].map((p, i) => ({
+				...p,
+				y: i ? p.y : 0
+			}))
+		})) : [];
+		this.strokes(ctx, "pace", paced, axes, this.curveOf(CurveKind.Linear), () => ctx.theme.inkMuted).attr("stroke-dasharray", "5 4");
+		this.hoverColumns(ctx, axes, series);
+	}
+};
+export { CumulativeLine };