watch-tail 0.4.0 → 0.5.0

package/build/server/chunks/chunks/Arc.canvas.js-D6g58nSp.js

@@ -0,0 +1,701 @@
+import { at as spread_props, am as bind_props, ac as derived, al as stringify } from './server.js-CAEBuMIH.js';
+import { a as getChartContext, b as cls } from './common.js-BWQB8Die.js';
+import { l as linear } from './linear.js-CTOKrHn9.js';
+import { m as max$1 } from './max.js-CuS0BpRI.js';
+import { e as extractLayerProps } from './attributes.js-BVWo7wbg.js';
+import { w as withPath, c as constant_default } from './path2.js-pquT2Kg6.js';
+import { a as Path_svg, b as Path_canvas } from './Path.canvas.js-DNAtnEBt.js';
+import { d as createMotion } from './motion.svelte.js-DCHSFMu-.js';
+import { d as degreesToRadians, r as radiansToDegrees } from './math.js-BqujbaBs.js';
+
+//#region node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/math.js
+var abs = Math.abs;
+var atan2 = Math.atan2;
+var cos = Math.cos;
+var max = Math.max;
+var min = Math.min;
+var sin = Math.sin;
+var sqrt = Math.sqrt;
+var pi = Math.PI;
+var halfPi = pi / 2;
+var 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);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/arc.js
+function arcInnerRadius(d) {
+	return d.innerRadius;
+}
+function arcOuterRadius(d) {
+	return d.outerRadius;
+}
+function arcStartAngle(d) {
+	return d.startAngle;
+}
+function arcEndAngle(d) {
+	return d.endAngle;
+}
+function arcPadAngle(d) {
+	return d && d.padAngle;
+}
+function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
+	var x10 = x1 - x0, y10 = y1 - y0, x32 = x3 - x2, y32 = y3 - y2, t = y32 * x10 - x32 * y10;
+	if (t * t < 1e-12) return;
+	t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
+	return [x0 + t * x10, y0 + t * y10];
+}
+function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
+	var x01 = x0 - x1, y01 = y0 - y1, lo = (cw ? rc : -rc) / sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x11 = x0 + ox, y11 = y0 + oy, x10 = x1 + ox, y10 = y1 + oy, x00 = (x11 + x10) / 2, y00 = (y11 + y10) / 2, dx = x10 - x11, dy = y10 - y11, d2 = dx * dx + dy * dy, r = r1 - rc, D = x11 * y10 - x10 * y11, d = (dy < 0 ? -1 : 1) * sqrt(max(0, r * r * d2 - D * D)), cx0 = (D * dy - dx * d) / d2, cy0 = (-D * dx - dy * d) / d2, cx1 = (D * dy + dx * d) / d2, cy1 = (-D * dx + dy * d) / d2, dx0 = cx0 - x00, dy0 = cy0 - y00, dx1 = cx1 - x00, 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 arc_default() {
+	var innerRadius = arcInnerRadius, outerRadius = arcOuterRadius, cornerRadius = constant_default(0), padRadius = null, startAngle = arcStartAngle, endAngle = arcEndAngle, padAngle = arcPadAngle, context = null, path = withPath(arc);
+	function arc() {
+		var buffer, r, r0 = +innerRadius.apply(this, arguments), r1 = +outerRadius.apply(this, arguments), a0 = startAngle.apply(this, arguments) - halfPi, a1 = endAngle.apply(this, arguments) - halfPi, da = abs(a1 - a0), cw = a1 > a0;
+		if (!context) context = buffer = path();
+		if (r1 < r0) r = r1, r1 = r0, r0 = r;
+		if (!(r1 > 1e-12)) context.moveTo(0, 0);
+		else if (da > tau - 1e-12) {
+			context.moveTo(r1 * cos(a0), r1 * sin(a0));
+			context.arc(0, 0, r1, a0, a1, !cw);
+			if (r0 > 1e-12) {
+				context.moveTo(r0 * cos(a1), r0 * sin(a1));
+				context.arc(0, 0, r0, a1, a0, cw);
+			}
+		} else {
+			var a01 = a0, a11 = a1, a00 = a0, a10 = a1, da0 = da, da1 = da, ap = padAngle.apply(this, arguments) / 2, rp = ap > 1e-12 && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)), rc = min(abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), rc0 = rc, rc1 = rc, t0, t1;
+			if (rp > 1e-12) {
+				var p0 = asin(rp / r0 * sin(ap)), p1 = asin(rp / r1 * sin(ap));
+				if ((da0 -= p0 * 2) > 1e-12) p0 *= cw ? 1 : -1, a00 += p0, a10 -= p0;
+				else da0 = 0, a00 = a10 = (a0 + a1) / 2;
+				if ((da1 -= p1 * 2) > 1e-12) p1 *= cw ? 1 : -1, a01 += p1, a11 -= p1;
+				else da1 = 0, a01 = a11 = (a0 + a1) / 2;
+			}
+			var x01 = r1 * cos(a01), y01 = r1 * sin(a01), x10 = r0 * cos(a10), y10 = r0 * sin(a10);
+			if (rc > 1e-12) {
+				var x11 = r1 * cos(a11), y11 = r1 * sin(a11), x00 = r0 * cos(a00), y00 = r0 * sin(a00), oc;
+				if (da < pi) {
+					if (oc = intersect(x01, y01, x00, y00, x11, y11, x10, y10)) {
+						var ax = x01 - oc[0], ay = y01 - oc[1], bx = x11 - oc[0], by = y11 - oc[1], kc = 1 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2), lc = sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
+						rc0 = min(rc, (r0 - lc) / (kc - 1));
+						rc1 = min(rc, (r1 - lc) / (kc + 1));
+					} else rc0 = rc1 = 0;
+				}
+			}
+			if (!(da1 > 1e-12)) context.moveTo(x01, y01);
+			else if (rc1 > 1e-12) {
+				t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
+				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, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw);
+				else {
+					context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw);
+					context.arc(0, 0, r1, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);
+					context.arc(t1.cx, t1.cy, rc1, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw);
+				}
+			} else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);
+			if (!(r0 > 1e-12) || !(da0 > 1e-12)) context.lineTo(x10, y10);
+			else if (rc0 > 1e-12) {
+				t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
+				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, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw);
+				else {
+					context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw);
+					context.arc(0, 0, r0, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);
+					context.arc(t1.cx, t1.cy, rc0, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw);
+				}
+			} else context.arc(0, 0, r0, a10, a00, cw);
+		}
+		context.closePath();
+		if (buffer) return context = null, buffer + "" || null;
+	}
+	arc.centroid = function() {
+		var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi / 2;
+		return [cos(a) * r, sin(a) * r];
+	};
+	arc.innerRadius = function(_) {
+		return arguments.length ? (innerRadius = typeof _ === "function" ? _ : constant_default(+_), arc) : innerRadius;
+	};
+	arc.outerRadius = function(_) {
+		return arguments.length ? (outerRadius = typeof _ === "function" ? _ : constant_default(+_), arc) : outerRadius;
+	};
+	arc.cornerRadius = function(_) {
+		return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : constant_default(+_), arc) : cornerRadius;
+	};
+	arc.padRadius = function(_) {
+		return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : constant_default(+_), arc) : padRadius;
+	};
+	arc.startAngle = function(_) {
+		return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant_default(+_), arc) : startAngle;
+	};
+	arc.endAngle = function(_) {
+		return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant_default(+_), arc) : endAngle;
+	};
+	arc.padAngle = function(_) {
+		return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant_default(+_), arc) : padAngle;
+	};
+	arc.context = function(_) {
+		return arguments.length ? (context = _ == null ? null : _, arc) : context;
+	};
+	return arc;
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/utils/arcText.svelte.js
+function extractOutsideArc(arcPath) {
+	const matches = arcPath.match(/(^.+?)(L|Z)/);
+	if (!matches || !matches[1]) return arcPath;
+	return matches[1];
+}
+function normalizeAngle(angle) {
+	return (angle % 360 + 360) % 360;
+}
+/**
+* Calculates and generates a path in the middle/medial line of an arc.
+*/
+function getArcPathMiddle(props) {
+	const centerRadius = derived(() => (props.innerRadius() + props.outerRadius()) / 2);
+	const cornerAngleOffset = derived(() => {
+		if (props.cornerRadius() <= 0 || centerRadius() <= 0) return 0;
+		return Math.min(props.cornerRadius(), centerRadius()) * .5 / centerRadius();
+	});
+	const effectiveStartAngle = derived(() => {
+		if (props.invertCorner()) return props.startAngle() - cornerAngleOffset();
+		return props.startAngle() + cornerAngleOffset();
+	});
+	const effectiveEndAngle = derived(() => {
+		if (props.invertCorner()) return props.endAngle() + cornerAngleOffset();
+		return props.endAngle() - cornerAngleOffset();
+	});
+	const path = derived(() => extractOutsideArc(arc_default().outerRadius(centerRadius()).innerRadius(centerRadius() - .5).startAngle(effectiveStartAngle()).endAngle(effectiveEndAngle())() ?? ""));
+	return { get current() {
+		return path();
+	} };
+}
+function getArcPathInner(props) {
+	const cornerAngleOffset = derived(() => {
+		if (props.cornerRadius() <= 0 || props.innerRadius() <= 0) return 0;
+		if (props.cornerRadius() >= props.innerRadius()) return Math.PI / 4;
+		return props.cornerRadius() * .5 / props.innerRadius();
+	});
+	const effectiveStartAngle = derived(() => {
+		if (props.invertCorner()) return props.startAngle() - cornerAngleOffset();
+		return props.startAngle() + cornerAngleOffset();
+	});
+	const effectiveEndAngle = derived(() => {
+		if (props.invertCorner()) return props.endAngle() + cornerAngleOffset();
+		return props.endAngle() - cornerAngleOffset();
+	});
+	const path = derived(() => extractOutsideArc(arc_default().innerRadius(props.innerRadius()).outerRadius(props.innerRadius() + .5).startAngle(effectiveStartAngle()).endAngle(effectiveEndAngle())() ?? ""));
+	return { get current() {
+		return path();
+	} };
+}
+function getArcPathOuter(props) {
+	const cornerAngleOffset = derived(() => {
+		if (props.cornerRadius() <= 0 || props.outerRadius() <= 0) return 0;
+		return props.cornerRadius() * .5 / props.outerRadius();
+	});
+	const effectiveStartAngle = derived(() => {
+		if (props.invertCorner()) return props.startAngle() - cornerAngleOffset();
+		return props.startAngle() + cornerAngleOffset();
+	});
+	const effectiveEndAngle = derived(() => {
+		if (props.invertCorner()) return props.endAngle() + cornerAngleOffset();
+		return props.endAngle() - cornerAngleOffset();
+	});
+	const path = derived(() => extractOutsideArc(arc_default().innerRadius(props.outerRadius() - .5).outerRadius(props.outerRadius()).startAngle(effectiveStartAngle()).endAngle(effectiveEndAngle())() ?? ""));
+	return { get current() {
+		return path();
+	} };
+}
+function pointOnCircle(radius, angle) {
+	const adjustedAngle = angle - Math.PI / 2;
+	return [radius * Math.cos(adjustedAngle), radius * Math.sin(adjustedAngle)];
+}
+function createArcTextProps(props, opts = {}, position) {
+	const effectiveStartAngleRadians = derived(() => {
+		const start = props.startAngle();
+		const end = props.endAngle();
+		const offset = opts.startOffset;
+		if (offset) try {
+			const percentage = parseFloat(offset.slice(0, -1)) / 100;
+			if (!isNaN(percentage) && percentage >= 0 && percentage <= 1) return start + (end - start) * percentage;
+			else console.warn("Invalid percentage for startOffset:", offset);
+		} catch (e) {
+			console.warn("Could not parse startOffset percentage:", offset, e);
+		}
+		return start;
+	});
+	const effectiveStartDegrees = derived(() => radiansToDegrees(effectiveStartAngleRadians()));
+	const normalizedStartDegrees = derived(() => normalizeAngle(effectiveStartDegrees()));
+	const startDegrees = derived(() => radiansToDegrees(props.startAngle()));
+	const endDegrees = derived(() => radiansToDegrees(props.endAngle()));
+	const isClockwise = derived(() => startDegrees() < endDegrees());
+	const isTopCw = derived(() => isClockwise() && (normalizedStartDegrees() >= 270 || normalizedStartDegrees() <= 90));
+	const isTopCcw = derived(() => !isClockwise() && (normalizedStartDegrees() > 270 || normalizedStartDegrees() <= 90));
+	const isBottomCw = derived(() => isClockwise() && normalizedStartDegrees() < 270 && normalizedStartDegrees() >= 90);
+	const isBottomCcw = derived(() => !isClockwise() && normalizedStartDegrees() <= 270 && normalizedStartDegrees() > 90);
+	const reverseText = derived(() => isTopCcw() || isBottomCw());
+	const pathGenProps = {
+		...props,
+		startAngle: () => reverseText() ? props.endAngle() : props.startAngle(),
+		endAngle: () => reverseText() ? props.startAngle() : props.endAngle(),
+		invertCorner: () => isBottomCw() || isBottomCcw()
+	};
+	const innerPath = getArcPathInner(pathGenProps);
+	const middlePath = getArcPathMiddle(pathGenProps);
+	const outerPath = getArcPathOuter(pathGenProps);
+	const innerDominantBaseline = derived(() => {
+		if (isBottomCw() || isBottomCcw()) return "auto";
+		if (isTopCw() || isTopCcw()) return "hanging";
+		return "auto";
+	});
+	const outerDominantBaseline = derived(() => {
+		if (isBottomCw() || isBottomCcw()) return "hanging";
+	});
+	const sharedProps = derived(() => {
+		if (opts.startOffset != null) return {
+			startOffset: opts.startOffset,
+			textAnchor: "start"
+		};
+		return {
+			startOffset: "50%",
+			textAnchor: "middle"
+		};
+	});
+	const radialPositionProps = derived(() => {
+		if (position !== "outer-radial") return {};
+		const midAngle = (props.startAngle() + props.endAngle()) / 2;
+		const basePadding = opts.radialOffset ?? opts.outerPadding ?? 23;
+		const midAngleDegrees = normalizeAngle(radiansToDegrees(midAngle));
+		let textAnchor = "middle";
+		let effectivePadding = basePadding;
+		const isBottomZone = midAngleDegrees > 45 && midAngleDegrees < 135;
+		const isTopZone = midAngleDegrees > 225 && midAngleDegrees < 315;
+		const isRightZone = midAngleDegrees <= 45 || midAngleDegrees >= 315;
+		const isLeftZone = midAngleDegrees >= 135 && midAngleDegrees <= 225;
+		const [x, y] = pointOnCircle(props.outerRadius() + effectivePadding, midAngle);
+		if (isRightZone) {
+			textAnchor = "start";
+			if (midAngleDegrees > 350 || midAngleDegrees < 10) textAnchor = "start";
+		} else if (isLeftZone) {
+			textAnchor = "end";
+			if (midAngleDegrees > 170 && midAngleDegrees < 190) textAnchor = "end";
+		} else if (isBottomZone) textAnchor = "middle";
+		else if (isTopZone) textAnchor = "middle";
+		return {
+			x,
+			y,
+			textAnchor,
+			dominantBaseline: "middle"
+		};
+	});
+	const current = derived(() => {
+		if (position === "inner") return {
+			path: innerPath.current,
+			...sharedProps(),
+			dominantBaseline: innerDominantBaseline()
+		};
+		else if (position === "outer") return {
+			path: outerPath.current,
+			...sharedProps(),
+			dominantBaseline: outerDominantBaseline()
+		};
+		else if (position === "middle") return {
+			path: middlePath.current,
+			...sharedProps(),
+			dominantBaseline: "middle"
+		};
+		else if (position === "centroid") {
+			const centroid = props.centroid();
+			return {
+				x: centroid[0],
+				y: centroid[1],
+				textAnchor: "middle",
+				verticalAnchor: "middle"
+			};
+		} else return radialPositionProps();
+	});
+	return { get current() {
+		return current();
+	} };
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/Arc/Arc.shared.svelte.js
+function getOuterRadius(outerRadius, chartRadius) {
+	if (!outerRadius) return chartRadius;
+	if (outerRadius > 1) return outerRadius;
+	if (outerRadius > 0) return chartRadius * outerRadius;
+	if (outerRadius < 0) return chartRadius + outerRadius;
+	return outerRadius;
+}
+/**
+* Reactive state shared by every per-layer Arc variant. Derives the d3-arc
+* generators (`arc`, `trackArc`), resolved radii/angles, and the centroid
+* used for snippet props.
+*/
+var ArcState = class {
+	#getProps = () => ({});
+	/**
+	* Memoized props — the component's props closure allocates a fresh object
+	* (it spreads `rest`), so calling it once per derived meant one allocation
+	* per derived per update. Read it once here instead.
+	*/
+	#props = derived(() => this.#getProps());
+	ctx = getChartContext();
+	trackRef;
+	#motionEndAngle;
+	constructor(getProps) {
+		this.#getProps = getProps;
+		const initial = getProps();
+		this.#motionEndAngle = createMotion(initial.initialValue ?? 0, () => this.#props().value ?? 0, initial.motion);
+	}
+	get motionEndAngleValue() {
+		return this.#motionEndAngle.current;
+	}
+	#range = derived(() => this.#props().range ?? [0, 360]);
+	get range() {
+		return this.#range();
+	}
+	set range($$value) {
+		return this.#range($$value);
+	}
+	#domain = derived(() => this.#props().domain ?? [0, 100]);
+	get domain() {
+		return this.#domain();
+	}
+	set domain($$value) {
+		return this.#domain($$value);
+	}
+	#endAngle = derived(() => {
+		return this.#props().endAngle ?? degreesToRadians(this.ctx.config.xRange ? max$1(this.ctx.config.xRange) : max$1(this.range));
+	});
+	get endAngle() {
+		return this.#endAngle();
+	}
+	set endAngle($$value) {
+		return this.#endAngle($$value);
+	}
+	#scale = derived(() => linear().domain(this.domain).range(this.range));
+	get scale() {
+		return this.#scale();
+	}
+	set scale($$value) {
+		return this.#scale($$value);
+	}
+	#chartRadius = derived(() => (Math.min(this.ctx.width, this.ctx.height) ?? 0) / 2);
+	get chartRadius() {
+		return this.#chartRadius();
+	}
+	set chartRadius($$value) {
+		return this.#chartRadius($$value);
+	}
+	#outerRadius = derived(() => getOuterRadius(this.#props().outerRadius, this.chartRadius));
+	get outerRadius() {
+		return this.#outerRadius();
+	}
+	set outerRadius($$value) {
+		return this.#outerRadius($$value);
+	}
+	#trackOuterRadius = derived(() => {
+		const trackOuterRadiusProp = this.#props().trackOuterRadius;
+		return trackOuterRadiusProp ? getOuterRadius(trackOuterRadiusProp, this.chartRadius) : this.outerRadius;
+	});
+	get trackOuterRadius() {
+		return this.#trackOuterRadius();
+	}
+	set trackOuterRadius($$value) {
+		return this.#trackOuterRadius($$value);
+	}
+	#getInnerRadius(innerRadius, outerRadius) {
+		if (innerRadius == null) return Math.min(...this.ctx.yRange);
+		if (innerRadius > 1) return innerRadius;
+		if (innerRadius > 0) return outerRadius * innerRadius;
+		if (innerRadius < 0) return outerRadius + innerRadius;
+		return innerRadius;
+	}
+	#innerRadius = derived(() => this.#getInnerRadius(this.#props().innerRadius, this.outerRadius));
+	get innerRadius() {
+		return this.#innerRadius();
+	}
+	set innerRadius($$value) {
+		return this.#innerRadius($$value);
+	}
+	#trackInnerRadius = derived(() => {
+		const trackInnerRadiusProp = this.#props().trackInnerRadius;
+		return trackInnerRadiusProp ? this.#getInnerRadius(trackInnerRadiusProp, this.trackOuterRadius) : this.innerRadius;
+	});
+	get trackInnerRadius() {
+		return this.#trackInnerRadius();
+	}
+	set trackInnerRadius($$value) {
+		return this.#trackInnerRadius($$value);
+	}
+	#startAngle = derived(() => this.#props().startAngle ?? degreesToRadians(this.range[0]));
+	get startAngle() {
+		return this.#startAngle();
+	}
+	set startAngle($$value) {
+		return this.#startAngle($$value);
+	}
+	#trackStartAngle = derived(() => this.#props().trackStartAngle ?? this.#props().startAngle ?? degreesToRadians(this.range[0]));
+	get trackStartAngle() {
+		return this.#trackStartAngle();
+	}
+	set trackStartAngle($$value) {
+		return this.#trackStartAngle($$value);
+	}
+	#trackEndAngle = derived(() => this.#props().trackEndAngle ?? this.#props().endAngle ?? degreesToRadians(this.range[1]));
+	get trackEndAngle() {
+		return this.#trackEndAngle();
+	}
+	set trackEndAngle($$value) {
+		return this.#trackEndAngle($$value);
+	}
+	#trackCornerRadius = derived(() => this.#props().trackCornerRadius ?? this.#props().cornerRadius ?? 0);
+	get trackCornerRadius() {
+		return this.#trackCornerRadius();
+	}
+	set trackCornerRadius($$value) {
+		return this.#trackCornerRadius($$value);
+	}
+	#trackPadAngle = derived(() => this.#props().trackPadAngle ?? this.#props().padAngle ?? 0);
+	get trackPadAngle() {
+		return this.#trackPadAngle();
+	}
+	set trackPadAngle($$value) {
+		return this.#trackPadAngle($$value);
+	}
+	#arcEndAngle = derived(() => this.#props().endAngle ?? degreesToRadians(this.scale(this.motionEndAngleValue)));
+	get arcEndAngle() {
+		return this.#arcEndAngle();
+	}
+	set arcEndAngle($$value) {
+		return this.#arcEndAngle($$value);
+	}
+	#arc = derived(() => {
+		const props = this.#props();
+		return arc_default().innerRadius(this.innerRadius).outerRadius(this.outerRadius).startAngle(this.startAngle).endAngle(this.arcEndAngle).cornerRadius(props.cornerRadius ?? 0).padAngle(props.padAngle ?? 0);
+	});
+	get arc() {
+		return this.#arc();
+	}
+	set arc($$value) {
+		return this.#arc($$value);
+	}
+	#trackArc = derived(() => arc_default().innerRadius(this.trackInnerRadius).outerRadius(this.trackOuterRadius).startAngle(this.trackStartAngle).endAngle(this.trackEndAngle).cornerRadius(this.trackCornerRadius).padAngle(this.trackPadAngle));
+	get trackArc() {
+		return this.#trackArc();
+	}
+	set trackArc($$value) {
+		return this.#trackArc($$value);
+	}
+	#angle = derived(() => ((this.startAngle ?? 0) + (this.endAngle ?? 0)) / 2);
+	get angle() {
+		return this.#angle();
+	}
+	set angle($$value) {
+		return this.#angle($$value);
+	}
+	#xOffset = derived(() => Math.sin(this.angle) * (this.#props().offset ?? 0));
+	get xOffset() {
+		return this.#xOffset();
+	}
+	set xOffset($$value) {
+		return this.#xOffset($$value);
+	}
+	#yOffset = derived(() => -Math.cos(this.angle) * (this.#props().offset ?? 0));
+	get yOffset() {
+		return this.#yOffset();
+	}
+	set yOffset($$value) {
+		return this.#yOffset($$value);
+	}
+	#trackArcCentroid = derived(() => {
+		const centroid = this.trackArc.centroid();
+		return [centroid[0] + this.xOffset, centroid[1] + this.yOffset];
+	});
+	get trackArcCentroid() {
+		return this.#trackArcCentroid();
+	}
+	set trackArcCentroid($$value) {
+		return this.#trackArcCentroid($$value);
+	}
+	#boundingBox = derived(() => this.trackRef ? this.trackRef.getBBox() : {});
+	get boundingBox() {
+		return this.#boundingBox();
+	}
+	set boundingBox($$value) {
+		return this.#boundingBox($$value);
+	}
+	getTrackTextProps = (position, opts = {}) => {
+		return createArcTextProps({
+			startAngle: () => this.trackStartAngle,
+			endAngle: () => this.trackEndAngle,
+			outerRadius: () => this.trackOuterRadius + (opts.outerPadding ?? 0),
+			innerRadius: () => this.trackInnerRadius - (opts.innerPadding ?? 0),
+			cornerRadius: () => this.trackCornerRadius,
+			centroid: () => this.trackArcCentroid
+		}, opts, position).current;
+	};
+	getArcTextProps = (position, opts = {}) => {
+		return createArcTextProps({
+			startAngle: () => this.startAngle,
+			endAngle: () => this.arcEndAngle,
+			outerRadius: () => this.outerRadius + (opts.outerPadding ?? 0),
+			innerRadius: () => this.innerRadius - (opts.innerPadding ?? 0),
+			cornerRadius: () => this.#props().cornerRadius ?? 0,
+			centroid: () => this.trackArcCentroid
+		}, opts, position).current;
+	};
+};
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/Arc/Arc.base.svelte
+function Arc_base($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { Path, ref: refProp = void 0, trackRef: trackRefProp = void 0, stroke = "none", motion, value, initialValue, domain, range, startAngle, endAngle, innerRadius, outerRadius, cornerRadius, padAngle, trackStartAngle, trackEndAngle, trackInnerRadius, trackOuterRadius, trackCornerRadius, trackPadAngle, offset, data, tooltip, track = false, onpointerenter = () => {}, onpointermove = () => {}, onpointerleave = () => {}, ontouchmove = () => {}, children, class: className, $$slots, $$events, ...restProps } = $$props;
+		const c = new ArcState(() => ({
+			motion,
+			value,
+			initialValue,
+			domain,
+			range,
+			startAngle,
+			endAngle,
+			innerRadius,
+			outerRadius,
+			cornerRadius,
+			padAngle,
+			trackStartAngle,
+			trackEndAngle,
+			trackInnerRadius,
+			trackOuterRadius,
+			trackCornerRadius,
+			trackPadAngle,
+			offset
+		}));
+		let ref = void 0;
+		const onPointerEnter = (e) => {
+			onpointerenter?.(e);
+			if (tooltip) c.ctx.tooltip.show(e, data);
+		};
+		const onPointerMove = (e) => {
+			onpointermove?.(e);
+			if (tooltip) c.ctx.tooltip.show(e, data);
+		};
+		const onPointerLeave = (e) => {
+			onpointerleave?.(e);
+			if (tooltip) c.ctx.tooltip.hide();
+		};
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (track) {
+				$$renderer.push("<!--[0-->");
+				var bind_get = () => c.trackRef;
+				var bind_set = (v) => c.trackRef = v;
+				if (Path) {
+					$$renderer.push("<!--[-->");
+					Path($$renderer, spread_props([{
+						pathData: c.trackArc(),
+						stroke: "none",
+						get pathRef() {
+							return bind_get();
+						},
+						set pathRef($$value) {
+							bind_set($$value);
+						}
+					}, extractLayerProps(track, "lc-arc-track")]));
+					$$renderer.push("<!--]-->");
+				} else {
+					$$renderer.push("<!--[!-->");
+					$$renderer.push("<!--]-->");
+				}
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]--> `);
+			if (Path) {
+				$$renderer.push("<!--[-->");
+				Path($$renderer, spread_props([
+					{
+						pathData: c.arc(),
+						transform: `translate(${stringify(c.xOffset)}, ${stringify(c.yOffset)})`,
+						stroke
+					},
+					restProps,
+					{
+						class: cls("lc-arc-line", className),
+						onpointerenter: onPointerEnter,
+						onpointermove: onPointerMove,
+						onpointerleave: onPointerLeave,
+						ontouchmove: (e) => {
+							ontouchmove?.(e);
+							if (tooltip) e.preventDefault();
+						},
+						get pathRef() {
+							return ref;
+						},
+						set pathRef($$value) {
+							ref = $$value;
+							$$settled = false;
+						}
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+			$$renderer.push(` `);
+			children?.($$renderer, {
+				centroid: c.trackArcCentroid,
+				boundingBox: c.boundingBox,
+				value: c.motionEndAngleValue,
+				startAngle: c.startAngle,
+				endAngle: c.arcEndAngle,
+				innerRadius: c.innerRadius,
+				outerRadius: c.outerRadius,
+				getTrackTextProps: c.getTrackTextProps,
+				getArcTextProps: c.getArcTextProps
+			});
+			$$renderer.push(`<!---->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, {
+			ref: refProp,
+			trackRef: trackRefProp
+		});
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/Arc/Arc.svg.svelte
+function Arc_svg($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Arc_base($$renderer, spread_props([{ Path: Path_svg }, props]));
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/Arc/Arc.canvas.svelte
+function Arc_canvas($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Arc_base($$renderer, spread_props([{ Path: Path_canvas }, props]));
+}
+
+export { Arc_svg as A, Arc_canvas as a };
+//# sourceMappingURL=Arc.canvas.js-D6g58nSp.js.map