@vizejs/ui 0.426.2 → 0.427.0

package/dist/chart-shape-CW2QdpYK.mjs

@@ -0,0 +1,974 @@
+//#region src/families/charts/chart-shape/shape-path.ts
+const pi$1 = Math.PI;
+const tau$1 = 2 * pi$1;
+const epsilon$1 = 1e-6;
+const tauEpsilon = tau$1 - epsilon$1;
+/**
+* Create an SVG path builder. `digits` rounds coordinates (d3-shape uses 3);
+* `null` keeps full precision.
+*
+* @throws RangeError for a negative or non-finite `digits`.
+*/
+function createPath(digits = 3) {
+	let text = "";
+	let x0 = null;
+	let y0 = null;
+	let x1 = null;
+	let y1 = null;
+	let format = (value) => String(value);
+	if (digits !== null) {
+		const d = Math.floor(digits);
+		if (!(d >= 0)) throw new RangeError(`VIZE_UI_PATH_DIGITS: invalid digits ${digits}`);
+		if (d <= 15) {
+			const k = 10 ** d;
+			format = (value) => String(Math.round(value * k) / k);
+		}
+	}
+	const n = (value) => format(value);
+	return {
+		moveTo(x, y) {
+			x0 = x1 = +x;
+			y0 = y1 = +y;
+			text += `M${n(x0)},${n(y0)}`;
+		},
+		closePath() {
+			if (x1 !== null) {
+				x1 = x0;
+				y1 = y0;
+				text += "Z";
+			}
+		},
+		lineTo(x, y) {
+			x1 = +x;
+			y1 = +y;
+			text += `L${n(x1)},${n(y1)}`;
+		},
+		bezierCurveTo(cx1, cy1, cx2, cy2, x, y) {
+			x1 = +x;
+			y1 = +y;
+			text += `C${n(+cx1)},${n(+cy1)},${n(+cx2)},${n(+cy2)},${n(x1)},${n(y1)}`;
+		},
+		arc(x, y, r, a0, a1, ccwInput = false) {
+			const ccw = Boolean(ccwInput);
+			if (r < 0) throw new RangeError(`VIZE_UI_PATH_RADIUS: negative radius ${r}`);
+			const dx = r * Math.cos(a0);
+			const dy = r * Math.sin(a0);
+			const startX = x + dx;
+			const startY = y + dy;
+			const cw = ccw ? 0 : 1;
+			let da = ccw ? a0 - a1 : a1 - a0;
+			if (x1 === null || y1 === null) text += `M${n(startX)},${n(startY)}`;
+			else if (Math.abs(x1 - startX) > epsilon$1 || Math.abs(y1 - startY) > epsilon$1) text += `L${n(startX)},${n(startY)}`;
+			if (!r) return;
+			if (da < 0) da = da % tau$1 + tau$1;
+			if (da > tauEpsilon) {
+				x1 = startX;
+				y1 = startY;
+				text += `A${n(r)},${n(r)},0,1,${cw},${n(x - dx)},${n(y - dy)}A${n(r)},${n(r)},0,1,${cw},${n(x1)},${n(y1)}`;
+			} else if (da > epsilon$1) {
+				x1 = x + r * Math.cos(a1);
+				y1 = y + r * Math.sin(a1);
+				text += `A${n(r)},${n(r)},0,${da >= pi$1 ? 1 : 0},${cw},${n(x1)},${n(y1)}`;
+			}
+		},
+		toString() {
+			return text;
+		}
+	};
+}
+//#endregion
+//#region src/families/charts/chart-shape/shape-arc.ts
+const epsilon = 1e-12;
+const pi = Math.PI;
+const halfPi = pi / 2;
+const tau = 2 * pi;
+function acos(x) {
+	return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);
+}
+function asin(x) {
+	return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x);
+}
+function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
+	const x10 = x1 - x0;
+	const y10 = y1 - y0;
+	const x32 = x3 - x2;
+	const y32 = y3 - y2;
+	let t = y32 * x10 - x32 * y10;
+	if (t * t < epsilon) return void 0;
+	t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
+	return [x0 + t * x10, y0 + t * y10];
+}
+function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
+	const x01 = x0 - x1;
+	const y01 = y0 - y1;
+	const lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01);
+	const ox = lo * y01;
+	const oy = -lo * x01;
+	const x11 = x0 + ox;
+	const y11 = y0 + oy;
+	const x10 = x1 + ox;
+	const y10 = y1 + oy;
+	const x00 = (x11 + x10) / 2;
+	const y00 = (y11 + y10) / 2;
+	const dx = x10 - x11;
+	const dy = y10 - y11;
+	const d2 = dx * dx + dy * dy;
+	const r = r1 - rc;
+	const D = x11 * y10 - x10 * y11;
+	const d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r * r * d2 - D * D));
+	let cx0 = (D * dy - dx * d) / d2;
+	let cy0 = (-D * dx - dy * d) / d2;
+	const cx1 = (D * dy + dx * d) / d2;
+	const cy1 = (-D * dx + dy * d) / d2;
+	const dx0 = cx0 - x00;
+	const dy0 = cy0 - y00;
+	const dx1 = cx1 - x00;
+	const dy1 = cy1 - y00;
+	if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) {
+		cx0 = cx1;
+		cy0 = cy1;
+	}
+	return {
+		cx: cx0,
+		cy: cy0,
+		x01: -ox,
+		y01: -oy,
+		x11: cx0 * (r1 / r - 1),
+		y11: cy0 * (r1 / r - 1)
+	};
+}
+function drawArc(context, geometry) {
+	let r0 = +geometry.innerRadius;
+	let r1 = +geometry.outerRadius;
+	const a0 = geometry.startAngle - halfPi;
+	const a1 = geometry.endAngle - halfPi;
+	const da = Math.abs(a1 - a0);
+	const cw = a1 > a0;
+	if (r1 < r0) [r0, r1] = [r1, r0];
+	if (!(r1 > epsilon)) context.moveTo(0, 0);
+	else if (da > tau - epsilon) {
+		context.moveTo(r1 * Math.cos(a0), r1 * Math.sin(a0));
+		context.arc(0, 0, r1, a0, a1, !cw);
+		if (r0 > epsilon) {
+			context.moveTo(r0 * Math.cos(a1), r0 * Math.sin(a1));
+			context.arc(0, 0, r0, a1, a0, cw);
+		}
+	} else {
+		let a01 = a0;
+		let a11 = a1;
+		let a00 = a0;
+		let a10 = a1;
+		let da0 = da;
+		let da1 = da;
+		const ap = (geometry.padAngle ?? 0) / 2;
+		const rp = ap > epsilon ? geometry.padRadius ?? Math.sqrt(r0 * r0 + r1 * r1) : 0;
+		const rc = Math.min(Math.abs(r1 - r0) / 2, geometry.cornerRadius ?? 0);
+		let rc0 = rc;
+		let rc1 = rc;
+		if (rp > epsilon) {
+			let p0 = asin(rp / r0 * Math.sin(ap));
+			let p1 = asin(rp / r1 * Math.sin(ap));
+			if ((da0 -= p0 * 2) > epsilon) {
+				p0 *= cw ? 1 : -1;
+				a00 += p0;
+				a10 -= p0;
+			} else {
+				da0 = 0;
+				a00 = a10 = (a0 + a1) / 2;
+			}
+			if ((da1 -= p1 * 2) > epsilon) {
+				p1 *= cw ? 1 : -1;
+				a01 += p1;
+				a11 -= p1;
+			} else {
+				da1 = 0;
+				a01 = a11 = (a0 + a1) / 2;
+			}
+		}
+		const x01 = r1 * Math.cos(a01);
+		const y01 = r1 * Math.sin(a01);
+		const x10 = r0 * Math.cos(a10);
+		const y10 = r0 * Math.sin(a10);
+		const x11 = r1 * Math.cos(a11);
+		const y11 = r1 * Math.sin(a11);
+		const x00 = r0 * Math.cos(a00);
+		const y00 = r0 * Math.sin(a00);
+		if (rc > epsilon && da < pi) {
+			const oc = intersect(x01, y01, x00, y00, x11, y11, x10, y10);
+			if (oc !== void 0) {
+				const ax = x01 - oc[0];
+				const ay = y01 - oc[1];
+				const bx = x11 - oc[0];
+				const by = y11 - oc[1];
+				const kc = 1 / Math.sin(acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2);
+				const lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
+				rc0 = Math.min(rc, (r0 - lc) / (kc - 1));
+				rc1 = Math.min(rc, (r1 - lc) / (kc + 1));
+			} else rc0 = rc1 = 0;
+		}
+		if (!(da1 > epsilon)) context.moveTo(x01, y01);
+		else if (rc1 > epsilon) {
+			const t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
+			const t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);
+			context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);
+			if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);
+			else {
+				context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);
+				context.arc(0, 0, r1, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);
+				context.arc(t1.cx, t1.cy, rc1, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);
+			}
+		} else {
+			context.moveTo(x01, y01);
+			context.arc(0, 0, r1, a01, a11, !cw);
+		}
+		if (!(r0 > epsilon) || !(da0 > epsilon)) context.lineTo(x10, y10);
+		else if (rc0 > epsilon) {
+			const t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
+			const t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);
+			context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);
+			if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);
+			else {
+				context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);
+				context.arc(0, 0, r0, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);
+				context.arc(t1.cx, t1.cy, rc0, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);
+			}
+		} else context.arc(0, 0, r0, a10, a00, cw);
+	}
+	context.closePath();
+}
+/**
+* Generate the SVG path of a circular or annular sector centered at the origin.
+*
+* @example
+* ```ts
+* arcPath({ innerRadius: 40, outerRadius: 80, startAngle: 0, endAngle: Math.PI / 2 });
+* ```
+*/
+function arcPath(geometry, digits = 3) {
+	const path = createPath(digits);
+	drawArc(path, geometry);
+	return path.toString();
+}
+/** Midpoint of an arc, useful for labels and tooltips. */
+function arcCentroid(geometry) {
+	const r = (geometry.innerRadius + geometry.outerRadius) / 2;
+	const a = (geometry.startAngle + geometry.endAngle) / 2 - pi / 2;
+	return [Math.cos(a) * r, Math.sin(a) * r];
+}
+/** Compute pie or donut slice angles. Slices are returned in input order. */
+function pieLayout(data, options) {
+	const n = data.length;
+	const a0 = options.startAngle ?? 0;
+	const da = Math.min(tau, Math.max(-tau, (options.endAngle ?? tau) - a0));
+	const p = Math.min(Math.abs(da) / n, options.padAngle ?? 0);
+	const pa = p * (da < 0 ? -1 : 1);
+	const values = data.map((datum, i) => +options.value(datum, i, data));
+	let sum = 0;
+	for (const value of values) if (value > 0) sum += value;
+	const order = values.map((_, i) => i);
+	const sort = options.sort ?? "descending";
+	if (sort === "descending") order.sort((i, j) => {
+		const left = values[i] ?? 0;
+		const right = values[j] ?? 0;
+		return right < left ? -1 : right > left ? 1 : right >= left ? 0 : NaN;
+	});
+	else if (typeof sort === "function") order.sort((i, j) => {
+		const left = data[i];
+		const right = data[j];
+		return left === void 0 || right === void 0 ? 0 : sort(left, right);
+	});
+	const k = sum ? (da - n * pa) / sum : 0;
+	const slices = Array.from({ length: n });
+	let angle = a0;
+	order.forEach((j, index) => {
+		const value = values[j] ?? 0;
+		const datum = data[j];
+		if (datum === void 0) return;
+		const end = angle + (value > 0 ? value * k : 0) + pa;
+		slices[j] = {
+			data: datum,
+			index,
+			value,
+			startAngle: angle,
+			endAngle: end,
+			padAngle: p
+		};
+		angle = end;
+	});
+	return slices.flatMap((slice) => slice === void 0 ? [] : [slice]);
+}
+//#endregion
+//#region src/families/charts/chart-shape/shape-bar.ts
+/**
+* Compute bar rectangles. Negative values grow away from the baseline in the
+* opposite direction, and widths and heights are always non-negative so the
+* result can be bound directly to SVG `<rect>` attributes.
+*/
+function barRects(data, options) {
+	const vertical = (options.orientation ?? "vertical") === "vertical";
+	const bandwidth = options.categoryScale.bandwidth;
+	return data.map((datum, index) => {
+		const value = +options.value(datum, index);
+		const base = typeof options.baseline === "function" ? options.baseline(datum, index) : options.baseline ?? 0;
+		const band = options.categoryScale(options.category(datum, index));
+		const from = options.valueScale(base);
+		const to = options.valueScale(value);
+		const low = Math.min(from, to);
+		const extent = Math.abs(to - from);
+		return vertical ? {
+			data: datum,
+			index,
+			value,
+			x: band,
+			y: low,
+			width: bandwidth,
+			height: extent
+		} : {
+			data: datum,
+			index,
+			value,
+			x: low,
+			y: band,
+			width: extent,
+			height: bandwidth
+		};
+	});
+}
+/**
+* SVG path for a rectangle with independently rounded corners, clamped so
+* opposite radii never overlap.
+*/
+function roundedRectPath(rect, radius, digits = 3) {
+	const { x, y, width, height } = rect;
+	const limit = Math.max(0, Math.min(width, height) / 2);
+	const read = (value) => Math.max(0, Math.min(limit, value ?? 0));
+	const corners = typeof radius === "number" ? {
+		topLeft: radius,
+		topRight: radius,
+		bottomRight: radius,
+		bottomLeft: radius
+	} : radius;
+	const tl = read(corners.topLeft);
+	const tr = read(corners.topRight);
+	const br = read(corners.bottomRight);
+	const bl = read(corners.bottomLeft);
+	const path = createPath(digits);
+	const quarter = Math.PI / 2;
+	path.moveTo(x + tl, y);
+	path.lineTo(x + width - tr, y);
+	if (tr) path.arc(x + width - tr, y + tr, tr, -quarter, 0);
+	path.lineTo(x + width, y + height - br);
+	if (br) path.arc(x + width - br, y + height - br, br, 0, quarter);
+	path.lineTo(x + bl, y + height);
+	if (bl) path.arc(x + bl, y + height - bl, bl, quarter, Math.PI);
+	path.lineTo(x, y + tl);
+	if (tl) path.arc(x + tl, y + tl, tl, Math.PI, Math.PI * 1.5);
+	path.closePath();
+	return path.toString();
+}
+//#endregion
+//#region src/families/charts/chart-shape/shape-curve.ts
+const curveEpsilon = 1e-12;
+function closeIfNeeded(state, context) {
+	if (state.line || state.line !== 0 && state.point === 1) context.closePath();
+	state.line = 1 - state.line;
+}
+/** Straight segments between points. */
+const curveLinear = (context) => {
+	const state = {
+		line: NaN,
+		point: 0
+	};
+	return {
+		areaStart: () => {
+			state.line = 0;
+		},
+		areaEnd: () => {
+			state.line = NaN;
+		},
+		lineStart: () => {
+			state.point = 0;
+		},
+		lineEnd: () => closeIfNeeded(state, context),
+		point: (x, y) => {
+			if (state.point === 0) {
+				state.point = 1;
+				if (state.line) context.lineTo(x, y);
+				else context.moveTo(x, y);
+			} else {
+				state.point = 2;
+				context.lineTo(x, y);
+			}
+		}
+	};
+};
+function sign(x) {
+	return x < 0 ? -1 : 1;
+}
+/** Cubic curve that preserves monotonicity in y for x-sorted data. */
+const curveMonotoneX = (context) => {
+	const state = {
+		line: NaN,
+		point: 0
+	};
+	let x0 = NaN;
+	let y0 = NaN;
+	let x1 = NaN;
+	let y1 = NaN;
+	let t0 = NaN;
+	const slope3 = (x2, y2) => {
+		const h0 = x1 - x0;
+		const h1 = x2 - x1;
+		const s0 = (y1 - y0) / (h0 || (h1 < 0 ? -0 : 0));
+		const s1 = (y2 - y1) / (h1 || (h0 < 0 ? -0 : 0));
+		const p = (s0 * h1 + s1 * h0) / (h0 + h1);
+		return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), .5 * Math.abs(p)) || 0;
+	};
+	const slope2 = (t) => {
+		const h = x1 - x0;
+		return h ? (3 * (y1 - y0) / h - t) / 2 : t;
+	};
+	const hermite = (startTangent, endTangent) => {
+		const dx = (x1 - x0) / 3;
+		context.bezierCurveTo(x0 + dx, y0 + dx * startTangent, x1 - dx, y1 - dx * endTangent, x1, y1);
+	};
+	return {
+		areaStart: () => {
+			state.line = 0;
+		},
+		areaEnd: () => {
+			state.line = NaN;
+		},
+		lineStart: () => {
+			x0 = x1 = y0 = y1 = t0 = NaN;
+			state.point = 0;
+		},
+		lineEnd: () => {
+			if (state.point === 2) context.lineTo(x1, y1);
+			else if (state.point === 3) hermite(t0, slope2(t0));
+			closeIfNeeded(state, context);
+		},
+		point: (x, y) => {
+			let t1 = NaN;
+			if (x === x1 && y === y1) return;
+			switch (state.point) {
+				case 0:
+					state.point = 1;
+					if (state.line) context.lineTo(x, y);
+					else context.moveTo(x, y);
+					break;
+				case 1:
+					state.point = 2;
+					break;
+				case 2:
+					state.point = 3;
+					t1 = slope3(x, y);
+					hermite(slope2(t1), t1);
+					break;
+				default:
+					t1 = slope3(x, y);
+					hermite(t0, t1);
+					break;
+			}
+			x0 = x1;
+			x1 = x;
+			y0 = y1;
+			y1 = y;
+			t0 = t1;
+		}
+	};
+};
+function stepCurve(initialT) {
+	return (context) => {
+		const state = {
+			line: NaN,
+			point: 0
+		};
+		let t = initialT;
+		let px = NaN;
+		let py = NaN;
+		return {
+			areaStart: () => {
+				state.line = 0;
+			},
+			areaEnd: () => {
+				state.line = NaN;
+			},
+			lineStart: () => {
+				px = py = NaN;
+				state.point = 0;
+			},
+			lineEnd: () => {
+				if (0 < t && t < 1 && state.point === 2) context.lineTo(px, py);
+				if (state.line || state.line !== 0 && state.point === 1) context.closePath();
+				if (state.line >= 0) {
+					t = 1 - t;
+					state.line = 1 - state.line;
+				}
+			},
+			point: (x, y) => {
+				if (state.point === 0) {
+					state.point = 1;
+					if (state.line) context.lineTo(x, y);
+					else context.moveTo(x, y);
+				} else {
+					state.point = 2;
+					if (t <= 0) {
+						context.lineTo(px, y);
+						context.lineTo(x, y);
+					} else {
+						const x1 = px * (1 - t) + x * t;
+						context.lineTo(x1, py);
+						context.lineTo(x1, y);
+					}
+				}
+				px = x;
+				py = y;
+			}
+		};
+	};
+}
+/** Horizontal-then-vertical steps centered between points. */
+const curveStep = stepCurve(.5);
+/** Vertical step at the start of each segment. */
+const curveStepBefore = stepCurve(0);
+/** Vertical step at the end of each segment. */
+const curveStepAfter = stepCurve(1);
+function cardinal(tension) {
+	const k = (1 - tension) / 6;
+	return (context) => {
+		const state = {
+			line: NaN,
+			point: 0
+		};
+		let x0 = NaN;
+		let x1 = NaN;
+		let x2 = NaN;
+		let y0 = NaN;
+		let y1 = NaN;
+		let y2 = NaN;
+		const segment = (x, y) => context.bezierCurveTo(x1 + k * (x2 - x0), y1 + k * (y2 - y0), x2 + k * (x1 - x), y2 + k * (y1 - y), x2, y2);
+		return {
+			areaStart: () => {
+				state.line = 0;
+			},
+			areaEnd: () => {
+				state.line = NaN;
+			},
+			lineStart: () => {
+				x0 = x1 = x2 = y0 = y1 = y2 = NaN;
+				state.point = 0;
+			},
+			lineEnd: () => {
+				if (state.point === 2) context.lineTo(x2, y2);
+				else if (state.point === 3) segment(x1, y1);
+				closeIfNeeded(state, context);
+			},
+			point: (x, y) => {
+				switch (state.point) {
+					case 0:
+						state.point = 1;
+						if (state.line) context.lineTo(x, y);
+						else context.moveTo(x, y);
+						break;
+					case 1:
+						state.point = 2;
+						x1 = x;
+						y1 = y;
+						break;
+					case 2:
+						state.point = 3;
+						segment(x, y);
+						break;
+					default:
+						segment(x, y);
+						break;
+				}
+				x0 = x1;
+				x1 = x2;
+				x2 = x;
+				y0 = y1;
+				y1 = y2;
+				y2 = y;
+			}
+		};
+	};
+}
+/**
+* Catmull–Rom spline through every point. `alpha` 0.5 (centripetal, the
+* default) avoids cusps and self-intersections; 0 is uniform, 1 chordal.
+*/
+function curveCatmullRom(alpha = .5) {
+	if (!alpha) return cardinal(0);
+	return (context) => {
+		const state = {
+			line: NaN,
+			point: 0
+		};
+		let x0 = NaN;
+		let x1 = NaN;
+		let x2 = NaN;
+		let y0 = NaN;
+		let y1 = NaN;
+		let y2 = NaN;
+		let l01a = 0;
+		let l12a = 0;
+		let l23a = 0;
+		let l01_2a = 0;
+		let l12_2a = 0;
+		let l23_2a = 0;
+		const segment = (x, y) => {
+			let cx1 = x1;
+			let cy1 = y1;
+			let cx2 = x2;
+			let cy2 = y2;
+			if (l01a > curveEpsilon) {
+				const a = 2 * l01_2a + 3 * l01a * l12a + l12_2a;
+				const n = 3 * l01a * (l01a + l12a);
+				cx1 = (cx1 * a - x0 * l12_2a + x2 * l01_2a) / n;
+				cy1 = (cy1 * a - y0 * l12_2a + y2 * l01_2a) / n;
+			}
+			if (l23a > curveEpsilon) {
+				const b = 2 * l23_2a + 3 * l23a * l12a + l12_2a;
+				const m = 3 * l23a * (l23a + l12a);
+				cx2 = (cx2 * b + x1 * l23_2a - x * l12_2a) / m;
+				cy2 = (cy2 * b + y1 * l23_2a - y * l12_2a) / m;
+			}
+			context.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2);
+		};
+		const push = (x, y) => {
+			if (state.point) {
+				const x23 = x2 - x;
+				const y23 = y2 - y;
+				l23_2a = (x23 * x23 + y23 * y23) ** alpha;
+				l23a = Math.sqrt(l23_2a);
+			}
+			switch (state.point) {
+				case 0:
+					state.point = 1;
+					if (state.line) context.lineTo(x, y);
+					else context.moveTo(x, y);
+					break;
+				case 1:
+					state.point = 2;
+					break;
+				case 2:
+					state.point = 3;
+					segment(x, y);
+					break;
+				default:
+					segment(x, y);
+					break;
+			}
+			l01a = l12a;
+			l12a = l23a;
+			l01_2a = l12_2a;
+			l12_2a = l23_2a;
+			x0 = x1;
+			x1 = x2;
+			x2 = x;
+			y0 = y1;
+			y1 = y2;
+			y2 = y;
+		};
+		return {
+			areaStart: () => {
+				state.line = 0;
+			},
+			areaEnd: () => {
+				state.line = NaN;
+			},
+			lineStart: () => {
+				x0 = x1 = x2 = y0 = y1 = y2 = NaN;
+				l01a = l12a = l23a = l01_2a = l12_2a = l23_2a = 0;
+				state.point = 0;
+			},
+			lineEnd: () => {
+				if (state.point === 2) context.lineTo(x2, y2);
+				else if (state.point === 3) push(x2, y2);
+				closeIfNeeded(state, context);
+			},
+			point: push
+		};
+	};
+}
+const namedCurves = Object.freeze({
+	catmullRom: curveCatmullRom(.5),
+	linear: curveLinear,
+	monotoneX: curveMonotoneX,
+	step: curveStep,
+	stepAfter: curveStepAfter,
+	stepBefore: curveStepBefore
+});
+/** Resolve a curve name or factory. */
+function resolveCurve(curve) {
+	if (curve === void 0) return curveLinear;
+	return typeof curve === "function" ? curve : namedCurves[curve];
+}
+//#endregion
+//#region src/families/charts/chart-shape/shape-line.ts
+/**
+* Generate an SVG path for a line through `data`, or `null` when nothing is drawn.
+*
+* @example
+* ```ts
+* linePath(points, { x: (d) => xScale(d.date), y: (d) => yScale(d.value), curve: "monotoneX" });
+* ```
+*/
+function linePath(data, options) {
+	const path = createPath(options.digits === void 0 ? 3 : options.digits);
+	const output = resolveCurve(options.curve)(path);
+	const defined = options.defined;
+	let drawing = false;
+	for (let i = 0; i <= data.length; i++) {
+		const datum = i < data.length ? data[i] : void 0;
+		const isDefined = datum !== void 0 && i < data.length && (defined === void 0 || defined(datum, i, data));
+		if (isDefined !== drawing) {
+			drawing = isDefined;
+			if (drawing) output.lineStart();
+			else output.lineEnd();
+		}
+		if (drawing && datum !== void 0) output.point(+options.x(datum, i, data), +options.y(datum, i, data));
+	}
+	return path.toString() || null;
+}
+/** Generate an SVG path for an area between a baseline and a topline. */
+function areaPath(data, options) {
+	const path = createPath(options.digits === void 0 ? 3 : options.digits);
+	const output = resolveCurve(options.curve)(path);
+	const defined = options.defined;
+	const baseline = options.y0 ?? 0;
+	const y0 = typeof baseline === "number" ? () => baseline : baseline;
+	const x0z = [];
+	const y0z = [];
+	let drawing = false;
+	let segmentStart = 0;
+	for (let i = 0; i <= data.length; i++) {
+		const datum = i < data.length ? data[i] : void 0;
+		const isDefined = datum !== void 0 && i < data.length && (defined === void 0 || defined(datum, i, data));
+		if (isDefined !== drawing) {
+			drawing = isDefined;
+			if (drawing) {
+				segmentStart = i;
+				output.areaStart();
+				output.lineStart();
+			} else {
+				output.lineEnd();
+				output.lineStart();
+				for (let k = i - 1; k >= segmentStart; --k) output.point(x0z[k] ?? 0, y0z[k] ?? 0);
+				output.lineEnd();
+				output.areaEnd();
+			}
+		}
+		if (drawing && datum !== void 0) {
+			x0z[i] = +options.x(datum, i, data);
+			y0z[i] = +y0(datum, i, data);
+			output.point(options.x1 === void 0 ? x0z[i] ?? 0 : +options.x1(datum, i, data), +options.y1(datum, i, data));
+		}
+	}
+	return path.toString() || null;
+}
+//#endregion
+//#region src/families/charts/chart-shape/shape-stack.ts
+function seriesSum(series) {
+	let sum = 0;
+	for (const point of series) {
+		const value = +point[1];
+		if (value) sum += value;
+	}
+	return sum;
+}
+function orderNone(count) {
+	return Array.from({ length: count }, (_, i) => i);
+}
+function peak(series) {
+	let index = 0;
+	let max = -Infinity;
+	series.forEach((point, i) => {
+		const value = +point[1];
+		if (value > max) {
+			max = value;
+			index = i;
+		}
+	});
+	return index;
+}
+function computeOrder(series, order) {
+	const none = orderNone(series.length);
+	const sums = series.map(seriesSum);
+	const byValue = (values) => none.sort((a, b) => (values[a] ?? 0) - (values[b] ?? 0));
+	switch (order) {
+		case "ascending": return byValue(sums);
+		case "descending": return byValue(sums).reverse();
+		case "reverse": return none.reverse();
+		case "appearance": return byValue(series.map(peak));
+		case "insideOut": {
+			const appearance = computeOrder(series, "appearance");
+			let top = 0;
+			let bottom = 0;
+			const tops = [];
+			const bottoms = [];
+			for (const j of appearance) if (top < bottom) {
+				top += sums[j] ?? 0;
+				tops.push(j);
+			} else {
+				bottom += sums[j] ?? 0;
+				bottoms.push(j);
+			}
+			return bottoms.reverse().concat(tops);
+		}
+		default: return none;
+	}
+}
+function at(series, i, j) {
+	return i === void 0 ? void 0 : series[i]?.[j];
+}
+function offsetNone(series, order) {
+	const n = series.length;
+	if (!(n > 1)) return;
+	const m = series[order[0] ?? 0]?.length ?? 0;
+	for (let i = 1; i < n; ++i) for (let j = 0; j < m; ++j) {
+		const previous = at(series, order[i - 1], j);
+		const point = at(series, order[i], j);
+		if (previous === void 0 || point === void 0) continue;
+		point[0] = Number.isNaN(previous[1]) ? previous[0] : previous[1];
+		point[1] += point[0];
+	}
+}
+function offsetExpand(series, order) {
+	const n = series.length;
+	if (!(n > 0)) return;
+	const m = series[0]?.length ?? 0;
+	for (let j = 0; j < m; ++j) {
+		let y = 0;
+		for (let i = 0; i < n; ++i) y += series[i]?.[j]?.[1] || 0;
+		if (y) for (let i = 0; i < n; ++i) {
+			const point = series[i]?.[j];
+			if (point !== void 0) point[1] /= y;
+		}
+	}
+	offsetNone(series, order);
+}
+function offsetDiverging(series, order) {
+	const n = series.length;
+	if (!(n > 0)) return;
+	const m = series[order[0] ?? 0]?.length ?? 0;
+	for (let j = 0; j < m; ++j) {
+		let positive = 0;
+		let negative = 0;
+		for (let i = 0; i < n; ++i) {
+			const point = at(series, order[i], j);
+			if (point === void 0) continue;
+			const dy = point[1] - point[0];
+			if (dy > 0) {
+				point[0] = positive;
+				point[1] = positive += dy;
+			} else if (dy < 0) {
+				point[1] = negative;
+				point[0] = negative += dy;
+			} else {
+				point[0] = 0;
+				point[1] = dy;
+			}
+		}
+	}
+}
+function offsetSilhouette(series, order) {
+	const n = series.length;
+	if (!(n > 0)) return;
+	const first = series[order[0] ?? 0];
+	const m = first?.length ?? 0;
+	for (let j = 0; j < m; ++j) {
+		let y = 0;
+		for (let i = 0; i < n; ++i) y += series[i]?.[j]?.[1] || 0;
+		const point = first?.[j];
+		if (point !== void 0) {
+			point[0] = -y / 2;
+			point[1] += point[0];
+		}
+	}
+	offsetNone(series, order);
+}
+function offsetWiggle(series, order) {
+	const n = series.length;
+	const first = series[order[0] ?? 0];
+	const m = first?.length ?? 0;
+	if (!(n > 0) || !(m > 0) || first === void 0) return;
+	let y = 0;
+	let j = 1;
+	for (; j < m; ++j) {
+		let s1 = 0;
+		let s2 = 0;
+		for (let i = 0; i < n; ++i) {
+			const si = series[order[i] ?? 0];
+			const sij0 = si?.[j]?.[1] || 0;
+			let s3 = (sij0 - (si?.[j - 1]?.[1] || 0)) / 2;
+			for (let k = 0; k < i; ++k) {
+				const sk = series[order[k] ?? 0];
+				s3 += (sk?.[j]?.[1] || 0) - (sk?.[j - 1]?.[1] || 0);
+			}
+			s1 += sij0;
+			s2 += s3 * sij0;
+		}
+		const point = first[j - 1];
+		if (point !== void 0) {
+			point[0] = y;
+			point[1] += y;
+		}
+		if (s1) y -= s2 / s1;
+	}
+	const last = first[j - 1];
+	if (last !== void 0) {
+		last[0] = y;
+		last[1] += y;
+	}
+	offsetNone(series, order);
+}
+/**
+* Stack series for stacked bar and area charts. Series are returned in `keys`
+* order; `series.index` holds the stacking position.
+*
+* @example
+* ```ts
+* const series = stackLayout(rows, { keys: ["apples", "pears"], value: (row, key) => row[key] });
+* ```
+*/
+function stackLayout(data, options) {
+	const series = options.keys.map((key) => {
+		const points = data.map((datum, j) => {
+			return {
+				0: 0,
+				1: +options.value(datum, key, j, data),
+				data: datum
+			};
+		});
+		return Object.assign(points, {
+			key,
+			index: 0
+		});
+	});
+	const erased = series;
+	const order = computeOrder(erased, options.order ?? "none");
+	order.forEach((seriesIndex, position) => {
+		const target = series[seriesIndex];
+		if (target !== void 0) target.index = position;
+	});
+	switch (options.offset ?? "none") {
+		case "expand":
+			offsetExpand(erased, order);
+			break;
+		case "diverging":
+			offsetDiverging(erased, order);
+			break;
+		case "silhouette":
+			offsetSilhouette(erased, order);
+			break;
+		case "wiggle":
+			offsetWiggle(erased, order);
+			break;
+		default: offsetNone(erased, order);
+	}
+	return series;
+}
+//#endregion
+export { curveLinear as a, curveStepAfter as c, barRects as d, roundedRectPath as f, createPath as g, pieLayout as h, curveCatmullRom as i, curveStepBefore as l, arcPath as m, areaPath as n, curveMonotoneX as o, arcCentroid as p, linePath as r, curveStep as s, stackLayout as t, resolveCurve as u };