watch-tail 0.4.0 → 0.6.0

package/build/server/chunks/chunks/Path.canvas.js-DNAtnEBt.js

@@ -0,0 +1,1259 @@
+import { ak as ensure_array_like, ar as attributes, al as stringify, an as clsx, am as bind_props, as as props_id, at as spread_props, ac as derived, ag as attr } from './server.js-CAEBuMIH.js';
+import { a as getChartContext, b as cls, m as merge } from './common.js-BWQB8Die.js';
+import { g as getLayerContext, a as getMarkData, b as getGeoContext, h as hasAnyDataProp, r as resolveGeoDataPair, c as resolveDataProp, f as flattenPathData, d as createKey, e as renderPathData } from './key.svelte.js-CWIvXc6L.js';
+import { c as createControlledMotion, a as cubicInOut, e as extractTweenConfig, b as cubicIn, d as createMotion, f as createDataMotionMap } from './motion.svelte.js-DCHSFMu-.js';
+
+//#region node_modules/.pnpm/d3-path@3.1.0/node_modules/d3-path/src/path.js
+var pi = Math.PI;
+var tau = 2 * pi;
+var epsilon = 1e-6;
+var tauEpsilon = tau - epsilon;
+function append(strings) {
+	this._ += strings[0];
+	for (let i = 1, n = strings.length; i < n; ++i) this._ += arguments[i] + strings[i];
+}
+function appendRound(digits) {
+	let d = Math.floor(digits);
+	if (!(d >= 0)) throw new Error(`invalid digits: ${digits}`);
+	if (d > 15) return append;
+	const k = 10 ** d;
+	return function(strings) {
+		this._ += strings[0];
+		for (let i = 1, n = strings.length; i < n; ++i) this._ += Math.round(arguments[i] * k) / k + strings[i];
+	};
+}
+var Path = class {
+	constructor(digits) {
+		this._x0 = this._y0 = this._x1 = this._y1 = null;
+		this._ = "";
+		this._append = digits == null ? append : appendRound(digits);
+	}
+	moveTo(x, y) {
+		this._append`M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}`;
+	}
+	closePath() {
+		if (this._x1 !== null) {
+			this._x1 = this._x0, this._y1 = this._y0;
+			this._append`Z`;
+		}
+	}
+	lineTo(x, y) {
+		this._append`L${this._x1 = +x},${this._y1 = +y}`;
+	}
+	quadraticCurveTo(x1, y1, x, y) {
+		this._append`Q${+x1},${+y1},${this._x1 = +x},${this._y1 = +y}`;
+	}
+	bezierCurveTo(x1, y1, x2, y2, x, y) {
+		this._append`C${+x1},${+y1},${+x2},${+y2},${this._x1 = +x},${this._y1 = +y}`;
+	}
+	arcTo(x1, y1, x2, y2, r) {
+		x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
+		if (r < 0) throw new Error(`negative radius: ${r}`);
+		let x0 = this._x1, y0 = this._y1, x21 = x2 - x1, y21 = y2 - y1, x01 = x0 - x1, y01 = y0 - y1, l01_2 = x01 * x01 + y01 * y01;
+		if (this._x1 === null) this._append`M${this._x1 = x1},${this._y1 = y1}`;
+		else if (!(l01_2 > epsilon));
+		else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) this._append`L${this._x1 = x1},${this._y1 = y1}`;
+		else {
+			let x20 = x2 - x0, y20 = y2 - y0, l21_2 = x21 * x21 + y21 * y21, l20_2 = x20 * x20 + y20 * y20, l21 = Math.sqrt(l21_2), l01 = Math.sqrt(l01_2), l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), t01 = l / l01, t21 = l / l21;
+			if (Math.abs(t01 - 1) > epsilon) this._append`L${x1 + t01 * x01},${y1 + t01 * y01}`;
+			this._append`A${r},${r},0,0,${+(y01 * x20 > x01 * y20)},${this._x1 = x1 + t21 * x21},${this._y1 = y1 + t21 * y21}`;
+		}
+	}
+	arc(x, y, r, a0, a1, ccw) {
+		x = +x, y = +y, r = +r, ccw = !!ccw;
+		if (r < 0) throw new Error(`negative radius: ${r}`);
+		let dx = r * Math.cos(a0), dy = r * Math.sin(a0), x0 = x + dx, y0 = y + dy, cw = 1 ^ ccw, da = ccw ? a0 - a1 : a1 - a0;
+		if (this._x1 === null) this._append`M${x0},${y0}`;
+		else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) this._append`L${x0},${y0}`;
+		if (!r) return;
+		if (da < 0) da = da % tau + tau;
+		if (da > tauEpsilon) this._append`A${r},${r},0,1,${cw},${x - dx},${y - dy}A${r},${r},0,1,${cw},${this._x1 = x0},${this._y1 = y0}`;
+		else if (da > epsilon) this._append`A${r},${r},0,${+(da >= pi)},${cw},${this._x1 = x + r * Math.cos(a1)},${this._y1 = y + r * Math.sin(a1)}`;
+	}
+	rect(x, y, w, h) {
+		this._append`M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}h${w = +w}v${+h}h${-w}Z`;
+	}
+	toString() {
+		return this._;
+	}
+};
+function path() {
+	return new Path();
+}
+path.prototype = Path.prototype;
+//#endregion
+//#region node_modules/.pnpm/svelte@5.57.0/node_modules/svelte/src/transition/index.js
+/** @param {number} x */
+var linear = (x) => x;
+/**
+* Animates the opacity of an element from 0 to the current opacity for `in` transitions and from the current opacity to 0 for `out` transitions.
+*
+* @param {Element} node
+* @param {FadeParams} [params]
+* @returns {TransitionConfig}
+*/
+function fade(node, { delay = 0, duration = 400, easing = linear } = {}) {
+	const o = +getComputedStyle(node).opacity;
+	return {
+		delay,
+		duration,
+		easing,
+		css: (t) => `opacity: ${t * o}`
+	};
+}
+//#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/createId.js
+/**
+* Creates a unique ID for a given prefix and uid.
+*
+* @param prefix - prefix to use for the id
+* @param uid - the uid generated by $props.id()
+*/
+function createId(prefix, uid) {
+	return `${prefix}-${uid}`;
+}
+//#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/Group/Group.shared.svelte.js
+var defaultKey = (_, i) => i;
+var GroupState = 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());
+	chartCtx = getChartContext();
+	markData = getMarkData();
+	geo = getGeoContext();
+	#dataMode = derived(() => hasAnyDataProp(this.#props().x, this.#props().y));
+	get dataMode() {
+		return this.#dataMode();
+	}
+	set dataMode($$value) {
+		return this.#dataMode($$value);
+	}
+	#resolvedData = derived(() => this.dataMode ? this.markData(this.#props().data) : []);
+	#resolvedItems = derived(() => {
+		if (!this.dataMode) return [];
+		const keyFn = this.#props().key ?? defaultKey;
+		return this.#resolvedData().map((d, i) => {
+			const key = keyFn(d, i);
+			const resolved = this.#resolveGroup(d);
+			const animated = this.#dataMotionMap?.get(key);
+			return {
+				d,
+				key,
+				x: animated?.x ?? resolved.x,
+				y: animated?.y ?? resolved.y
+			};
+		});
+	});
+	get resolvedItems() {
+		return this.#resolvedItems();
+	}
+	set resolvedItems($$value) {
+		return this.#resolvedItems($$value);
+	}
+	#resolveGroup(d) {
+		const props = this.#props();
+		if (this.geo.projection) {
+			const [projX, projY] = resolveGeoDataPair(props.x, props.y, d, this.geo.projection);
+			return {
+				x: projX,
+				y: projY
+			};
+		}
+		return {
+			x: resolveDataProp(props.x, d, this.chartCtx.xScale, 0),
+			y: resolveDataProp(props.y, d, this.chartCtx.yScale, 0)
+		};
+	}
+	#trueX = derived(() => {
+		const props = this.#props();
+		if (typeof props.x === "number") return props.x;
+		if (props.x == null && (props.center === "x" || props.center === true)) return this.chartCtx.width / 2;
+		return 0;
+	});
+	get trueX() {
+		return this.#trueX();
+	}
+	set trueX($$value) {
+		return this.#trueX($$value);
+	}
+	#trueY = derived(() => {
+		const props = this.#props();
+		if (typeof props.y === "number") return props.y;
+		if (props.y == null && (props.center === "y" || props.center === true)) return this.chartCtx.height / 2;
+		return 0;
+	});
+	get trueY() {
+		return this.#trueY();
+	}
+	set trueY($$value) {
+		return this.#trueY($$value);
+	}
+	#series = derived(() => {
+		const seriesKey = this.#props().seriesKey;
+		if (seriesKey == null) return void 0;
+		return this.chartCtx.series.series.find((s) => s.key === seriesKey);
+	});
+	get series() {
+		return this.#series();
+	}
+	set series($$value) {
+		return this.#series($$value);
+	}
+	#hidden = derived(() => this.series != null && !this.chartCtx.series.isVisible(this.series.key));
+	get hidden() {
+		return this.#hidden();
+	}
+	set hidden($$value) {
+		return this.#hidden($$value);
+	}
+	#seriesOpacity = derived(() => {
+		if (this.series?.key == null || this.chartCtx.series.visibleSeries.length <= 1 || this.chartCtx.series.isHighlighted(this.series.key, true)) return 1;
+		return .1;
+	});
+	get seriesOpacity() {
+		return this.#seriesOpacity();
+	}
+	set seriesOpacity($$value) {
+		return this.#seriesOpacity($$value);
+	}
+	#opacity = derived(() => {
+		const opacity = this.#props().opacity;
+		if (this.seriesOpacity === 1) return opacity;
+		return (opacity ?? 1) * this.seriesOpacity;
+	});
+	get opacity() {
+		return this.#opacity();
+	}
+	set opacity($$value) {
+		return this.#opacity($$value);
+	}
+	#dataMotionMap = null;
+	#motionX;
+	#motionY;
+	get motionX() {
+		return this.#motionX.current;
+	}
+	get motionY() {
+		return this.#motionY.current;
+	}
+	#transform = derived(() => {
+		const props = this.#props();
+		if (props.center || props.x != null || props.y != null) return `translate(${this.motionX}px, ${this.motionY}px)`;
+	});
+	get transform() {
+		return this.#transform();
+	}
+	set transform($$value) {
+		return this.#transform($$value);
+	}
+	#defaultTransitionIn = derived(() => extractTweenConfig(this.#props().motion)?.options ? fade : () => ({}));
+	get defaultTransitionIn() {
+		return this.#defaultTransitionIn();
+	}
+	set defaultTransitionIn($$value) {
+		return this.#defaultTransitionIn($$value);
+	}
+	defaultTransitionInParams = { easing: cubicIn };
+	constructor(getProps) {
+		this.#getProps = getProps;
+		const initial = getProps();
+		const initialX = initial.initialX ?? (typeof initial.x === "number" ? initial.x : void 0);
+		const initialY = initial.initialY ?? (typeof initial.y === "number" ? initial.y : void 0);
+		this.#motionX = createMotion(initialX, () => this.trueX, initial.motion);
+		this.#motionY = createMotion(initialY, () => this.trueY, initial.motion);
+		this.#dataMotionMap = createDataMotionMap(initial.motion);
+		if (this.#dataMotionMap) this.#dataMotionMap;
+	}
+};
+//#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/Group/Group.svg.svelte
+function Group_svg($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { preventTouchMove = false, transitionIn: transitionInProp, transitionInParams: transitionInParamsProp, class: className, children, ref: refProp = void 0, x, y, initialX, initialY, data, key, center, motion, seriesKey, opacity, $$slots, $$events, ...rest } = $$props;
+		const c = new GroupState(() => ({
+			preventTouchMove,
+			transitionIn: transitionInProp,
+			transitionInParams: transitionInParamsProp,
+			class: className,
+			children,
+			x,
+			y,
+			initialX,
+			initialY,
+			data,
+			key,
+			center,
+			motion,
+			seriesKey,
+			opacity,
+			...rest
+		}));
+		if (c.hidden) $$renderer.push("<!--[0-->");
+		else if (c.dataMode) {
+			$$renderer.push(`<!--[1--><!--[-->`);
+			const each_array = ensure_array_like(c.resolvedItems);
+			for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+				let item = each_array[$$index];
+				$$renderer.push(`<g${attributes({
+					class: clsx(["lc-group-g", className]),
+					...rest,
+					opacity: c.opacity
+				}, void 0, void 0, { transform: `translate(${stringify(item.x)}px, ${stringify(item.y)}px)` }, 3)}>`);
+				children?.($$renderer);
+				$$renderer.push(`<!----></g>`);
+			}
+			$$renderer.push(`<!--]-->`);
+		} else {
+			$$renderer.push(`<!--[-1--><g${attributes({
+				class: clsx(["lc-group-g", className]),
+				...rest,
+				opacity: c.opacity
+			}, void 0, void 0, { transform: c.transform }, 3)}>`);
+			children?.($$renderer);
+			$$renderer.push(`<!----></g>`);
+		}
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, { ref: refProp });
+	});
+}
+//#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/Group/Group.canvas.svelte
+function Group_canvas($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { children, $$slots, $$events, ...rest } = $$props;
+		const c = new GroupState(() => ({
+			children,
+			...rest
+		}));
+		c.chartCtx.registerComponent({
+			name: "Group",
+			kind: "group",
+			canvasRender: {
+				render: (ctx) => {
+					ctx.translate(c.motionX ?? 0, c.motionY ?? 0);
+					if (c.opacity != null) ctx.globalAlpha *= c.opacity;
+				},
+				events: {
+					click: rest.onclick,
+					dblclick: rest.ondblclick,
+					pointerenter: rest.onpointerenter,
+					pointermove: rest.onpointermove,
+					pointerleave: rest.onpointerleave,
+					pointerdown: rest.onpointerdown
+				},
+				deps: () => [
+					c.motionX,
+					c.motionY,
+					c.opacity
+				]
+			}
+		});
+		if (!c.hidden) {
+			$$renderer.push("<!--[0-->");
+			children?.($$renderer);
+			$$renderer.push(`<!---->`);
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+	});
+}
+//#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/Group/Group.html.svelte
+function Group_html($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { preventTouchMove = false, transitionIn: transitionInProp, transitionInParams: transitionInParamsProp, class: className, children, ref: refProp = void 0, x, y, initialX, initialY, data, key, center, motion, seriesKey, opacity, $$slots, $$events, ...rest } = $$props;
+		const c = new GroupState(() => ({
+			preventTouchMove,
+			transitionIn: transitionInProp,
+			transitionInParams: transitionInParamsProp,
+			class: className,
+			children,
+			x,
+			y,
+			initialX,
+			initialY,
+			data,
+			key,
+			center,
+			motion,
+			seriesKey,
+			opacity,
+			...rest
+		}));
+		if (c.hidden) $$renderer.push("<!--[0-->");
+		else if (c.dataMode) {
+			$$renderer.push(`<!--[1--><!--[-->`);
+			const each_array = ensure_array_like(c.resolvedItems);
+			for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+				let item = each_array[$$index];
+				$$renderer.push(`<div${attributes({
+					...rest,
+					class: clsx(["lc-group-div", className])
+				}, "svelte-1mg96lr", void 0, {
+					transform: `translate(${stringify(item.x)}px, ${stringify(item.y)}px)`,
+					opacity: c.opacity
+				})}>`);
+				children?.($$renderer);
+				$$renderer.push(`<!----></div>`);
+			}
+			$$renderer.push(`<!--]-->`);
+		} else {
+			$$renderer.push(`<!--[-1--><div${attributes({
+				...rest,
+				class: clsx(["lc-group-div", className])
+			}, "svelte-1mg96lr", void 0, {
+				transform: c.transform,
+				opacity: c.opacity
+			})}>`);
+			children?.($$renderer);
+			$$renderer.push(`<!----></div>`);
+		}
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, { ref: refProp });
+	});
+}
+//#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/Group/Group.svelte
+function Group($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const layerCtx = getLayerContext();
+		let { ref = void 0, $$slots, $$events, ...rest } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (layerCtx === "svg") {
+				$$renderer.push("<!--[0-->");
+				Group_svg($$renderer, spread_props([rest, {
+					get ref() {
+						return ref;
+					},
+					set ref($$value) {
+						ref = $$value;
+						$$settled = false;
+					}
+				}]));
+			} else if (layerCtx === "canvas") {
+				$$renderer.push("<!--[1-->");
+				Group_canvas($$renderer, spread_props([rest]));
+			} else if (layerCtx === "html") {
+				$$renderer.push("<!--[2-->");
+				Group_html($$renderer, spread_props([rest, {
+					get ref() {
+						return ref;
+					},
+					set ref($$value) {
+						ref = $$value;
+						$$settled = false;
+					}
+				}]));
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]-->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#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/Marker.svelte
+function Marker($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { type, id = createId("marker-", uid), size = 10, markerWidth = size, markerHeight = size, markerUnits = "userSpaceOnUse", orient = "auto-start-reverse", refX = ["arrow", "triangle"].includes(type ?? "") ? 9 : 5, refY = 5, viewBox = "0 0 10 10", class: className, children, $$slots, $$events, ...restProps } = $$props;
+		$$renderer.push(`<defs><marker${attributes({
+			id,
+			markerWidth,
+			markerHeight,
+			markerUnits,
+			orient,
+			refX,
+			refY,
+			viewBox,
+			"data-type": type,
+			...restProps,
+			class: clsx(cls("lc-marker", className))
+		}, "svelte-1vpz1s3", void 0, void 0, 3)}>`);
+		if (children) {
+			$$renderer.push("<!--[0-->");
+			children($$renderer);
+			$$renderer.push(`<!---->`);
+		} else if (type === "triangle") $$renderer.push(`<!--[1--><path d="M 0 0 L 10 5 L 0 10 z" class="lc-marker-triangle"></path>`);
+		else if (type === "arrow") $$renderer.push(`<!--[2--><polyline points="0 0, 10 5, 0 10" class="lc-marker-arrow"></polyline>`);
+		else if (type === "circle" || type === "circle-stroke" || type === "dot") $$renderer.push(`<!--[3--><circle${attr("cx", 5)}${attr("cy", 5)}${attr("r", 5)} class="lc-marker-circle"></circle>`);
+		else if (type === "line") $$renderer.push(`<!--[4--><polyline points="5 0, 5 10" class="lc-marker-line"></polyline>`);
+		else if (type === "square" || type === "square-stroke") $$renderer.push(`<!--[5--><rect${attr("x", 0)}${attr("y", 0)}${attr("width", 10)}${attr("height", 10)} class="lc-marker-square"></rect>`);
+		else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]--></marker></defs>`);
+	});
+}
+//#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/MarkerWrapper.svelte
+function MarkerWrapper($$renderer, $$props) {
+	let { id, marker } = $$props;
+	if (typeof marker === "function") {
+		$$renderer.push("<!--[0-->");
+		marker($$renderer, { id });
+		$$renderer.push(`<!---->`);
+	} else if (marker) {
+		$$renderer.push("<!--[1-->");
+		Marker($$renderer, spread_props([{
+			id,
+			type: typeof marker === "string" ? marker : void 0
+		}, typeof marker === "object" ? marker : null]));
+	} else $$renderer.push("<!--[-1-->");
+	$$renderer.push(`<!--]-->`);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-interpolate-path@2.3.0/node_modules/d3-interpolate-path/build/d3-interpolate-path.mjs
+function ownKeys(object, enumerableOnly) {
+	var keys = Object.keys(object);
+	if (Object.getOwnPropertySymbols) {
+		var symbols = Object.getOwnPropertySymbols(object);
+		if (enumerableOnly) symbols = symbols.filter(function(sym) {
+			return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+		});
+		keys.push.apply(keys, symbols);
+	}
+	return keys;
+}
+function _objectSpread2(target) {
+	for (var i = 1; i < arguments.length; i++) {
+		var source = arguments[i] != null ? arguments[i] : {};
+		if (i % 2) ownKeys(Object(source), true).forEach(function(key) {
+			_defineProperty(target, key, source[key]);
+		});
+		else if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+		else ownKeys(Object(source)).forEach(function(key) {
+			Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+		});
+	}
+	return target;
+}
+function _typeof(obj) {
+	"@babel/helpers - typeof";
+	if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") _typeof = function(obj) {
+		return typeof obj;
+	};
+	else _typeof = function(obj) {
+		return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+	};
+	return _typeof(obj);
+}
+function _defineProperty(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+function _extends() {
+	_extends = Object.assign || function(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = arguments[i];
+			for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+		}
+		return target;
+	};
+	return _extends.apply(this, arguments);
+}
+function _unsupportedIterableToArray(o, minLen) {
+	if (!o) return;
+	if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+	var n = Object.prototype.toString.call(o).slice(8, -1);
+	if (n === "Object" && o.constructor) n = o.constructor.name;
+	if (n === "Map" || n === "Set") return Array.from(o);
+	if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+	if (len == null || len > arr.length) len = arr.length;
+	for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+	return arr2;
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+	var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+	if (!it) {
+		if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
+			if (it) o = it;
+			var i = 0;
+			var F = function() {};
+			return {
+				s: F,
+				n: function() {
+					if (i >= o.length) return { done: true };
+					return {
+						done: false,
+						value: o[i++]
+					};
+				},
+				e: function(e) {
+					throw e;
+				},
+				f: F
+			};
+		}
+		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	var normalCompletion = true, didErr = false, err;
+	return {
+		s: function() {
+			it = it.call(o);
+		},
+		n: function() {
+			var step = it.next();
+			normalCompletion = step.done;
+			return step;
+		},
+		e: function(e) {
+			didErr = true;
+			err = e;
+		},
+		f: function() {
+			try {
+				if (!normalCompletion && it.return != null) it.return();
+			} finally {
+				if (didErr) throw err;
+			}
+		}
+	};
+}
+/**
+* de Casteljau's algorithm for drawing and splitting bezier curves.
+* Inspired by https://pomax.github.io/bezierinfo/
+*
+* @param {Number[][]} points Array of [x,y] points: [start, control1, control2, ..., end]
+*   The original segment to split.
+* @param {Number} t Where to split the curve (value between [0, 1])
+* @return {Object} An object { left, right } where left is the segment from 0..t and
+*   right is the segment from t..1.
+*/
+function decasteljau(points, t) {
+	var left = [];
+	var right = [];
+	function decasteljauRecurse(points, t) {
+		if (points.length === 1) {
+			left.push(points[0]);
+			right.push(points[0]);
+		} else {
+			var newPoints = Array(points.length - 1);
+			for (var i = 0; i < newPoints.length; i++) {
+				if (i === 0) left.push(points[0]);
+				if (i === newPoints.length - 1) right.push(points[i + 1]);
+				newPoints[i] = [(1 - t) * points[i][0] + t * points[i + 1][0], (1 - t) * points[i][1] + t * points[i + 1][1]];
+			}
+			decasteljauRecurse(newPoints, t);
+		}
+	}
+	if (points.length) decasteljauRecurse(points, t);
+	return {
+		left,
+		right: right.reverse()
+	};
+}
+/**
+* Convert segments represented as points back into a command object
+*
+* @param {Number[][]} points Array of [x,y] points: [start, control1, control2, ..., end]
+*   Represents a segment
+* @return {Object} A command object representing the segment.
+*/
+function pointsToCommand(points) {
+	var command = {};
+	if (points.length === 4) {
+		command.x2 = points[2][0];
+		command.y2 = points[2][1];
+	}
+	if (points.length >= 3) {
+		command.x1 = points[1][0];
+		command.y1 = points[1][1];
+	}
+	command.x = points[points.length - 1][0];
+	command.y = points[points.length - 1][1];
+	if (points.length === 4) command.type = "C";
+	else if (points.length === 3) command.type = "Q";
+	else command.type = "L";
+	return command;
+}
+/**
+* Runs de Casteljau's algorithm enough times to produce the desired number of segments.
+*
+* @param {Number[][]} points Array of [x,y] points for de Casteljau (the initial segment to split)
+* @param {Number} segmentCount Number of segments to split the original into
+* @return {Number[][][]} Array of segments
+*/
+function splitCurveAsPoints(points, segmentCount) {
+	segmentCount = segmentCount || 2;
+	var segments = [];
+	var remainingCurve = points;
+	var tIncrement = 1 / segmentCount;
+	for (var i = 0; i < segmentCount - 1; i++) {
+		var tRelative = tIncrement / (1 - tIncrement * i);
+		var split = decasteljau(remainingCurve, tRelative);
+		segments.push(split.left);
+		remainingCurve = split.right;
+	}
+	segments.push(remainingCurve);
+	return segments;
+}
+/**
+* Convert command objects to arrays of points, run de Casteljau's algorithm on it
+* to split into to the desired number of segments.
+*
+* @param {Object} commandStart The start command object
+* @param {Object} commandEnd The end command object
+* @param {Number} segmentCount The number of segments to create
+* @return {Object[]} An array of commands representing the segments in sequence
+*/
+function splitCurve(commandStart, commandEnd, segmentCount) {
+	var points = [[commandStart.x, commandStart.y]];
+	if (commandEnd.x1 != null) points.push([commandEnd.x1, commandEnd.y1]);
+	if (commandEnd.x2 != null) points.push([commandEnd.x2, commandEnd.y2]);
+	points.push([commandEnd.x, commandEnd.y]);
+	return splitCurveAsPoints(points, segmentCount).map(pointsToCommand);
+}
+var commandTokenRegex = /[MLCSTQAHVZmlcstqahv]|-?[\d.e+-]+/g;
+/**
+* List of params for each command type in a path `d` attribute
+*/
+var typeMap = {
+	M: ["x", "y"],
+	L: ["x", "y"],
+	H: ["x"],
+	V: ["y"],
+	C: [
+		"x1",
+		"y1",
+		"x2",
+		"y2",
+		"x",
+		"y"
+	],
+	S: [
+		"x2",
+		"y2",
+		"x",
+		"y"
+	],
+	Q: [
+		"x1",
+		"y1",
+		"x",
+		"y"
+	],
+	T: ["x", "y"],
+	A: [
+		"rx",
+		"ry",
+		"xAxisRotation",
+		"largeArcFlag",
+		"sweepFlag",
+		"x",
+		"y"
+	],
+	Z: []
+};
+Object.keys(typeMap).forEach(function(key) {
+	typeMap[key.toLowerCase()] = typeMap[key];
+});
+function arrayOfLength(length, value) {
+	var array = Array(length);
+	for (var i = 0; i < length; i++) array[i] = value;
+	return array;
+}
+/**
+* Converts a command object to a string to be used in a `d` attribute
+* @param {Object} command A command object
+* @return {String} The string for the `d` attribute
+*/
+function commandToString(command) {
+	return "".concat(command.type).concat(typeMap[command.type].map(function(p) {
+		return command[p];
+	}).join(","));
+}
+/**
+* Converts command A to have the same type as command B.
+*
+* e.g., L0,5 -> C0,5,0,5,0,5
+*
+* Uses these rules:
+* x1 <- x
+* x2 <- x
+* y1 <- y
+* y2 <- y
+* rx <- 0
+* ry <- 0
+* xAxisRotation <- read from B
+* largeArcFlag <- read from B
+* sweepflag <- read from B
+*
+* @param {Object} aCommand Command object from path `d` attribute
+* @param {Object} bCommand Command object from path `d` attribute to match against
+* @return {Object} aCommand converted to type of bCommand
+*/
+function convertToSameType(aCommand, bCommand) {
+	var conversionMap = {
+		x1: "x",
+		y1: "y",
+		x2: "x",
+		y2: "y"
+	};
+	var readFromBKeys = [
+		"xAxisRotation",
+		"largeArcFlag",
+		"sweepFlag"
+	];
+	if (aCommand.type !== bCommand.type && bCommand.type.toUpperCase() !== "M") {
+		var aConverted = {};
+		Object.keys(bCommand).forEach(function(bKey) {
+			var bValue = bCommand[bKey];
+			var aValue = aCommand[bKey];
+			if (aValue === void 0) {
+				if (readFromBKeys.includes(bKey)) aValue = bValue;
+				else {
+					if (aValue === void 0 && conversionMap[bKey]) aValue = aCommand[conversionMap[bKey]];
+					if (aValue === void 0) aValue = 0;
+				}
+			}
+			aConverted[bKey] = aValue;
+		});
+		aConverted.type = bCommand.type;
+		aCommand = aConverted;
+	}
+	return aCommand;
+}
+/**
+* Interpolate between command objects commandStart and commandEnd segmentCount times.
+* If the types are L, Q, or C then the curves are split as per de Casteljau's algorithm.
+* Otherwise we just copy commandStart segmentCount - 1 times, finally ending with commandEnd.
+*
+* @param {Object} commandStart Command object at the beginning of the segment
+* @param {Object} commandEnd Command object at the end of the segment
+* @param {Number} segmentCount The number of segments to split this into. If only 1
+*   Then [commandEnd] is returned.
+* @return {Object[]} Array of ~segmentCount command objects between commandStart and
+*   commandEnd. (Can be segmentCount+1 objects if commandStart is type M).
+*/
+function splitSegment(commandStart, commandEnd, segmentCount) {
+	var segments = [];
+	if (commandEnd.type === "L" || commandEnd.type === "Q" || commandEnd.type === "C") segments = segments.concat(splitCurve(commandStart, commandEnd, segmentCount));
+	else {
+		var copyCommand = _extends({}, commandStart);
+		if (copyCommand.type === "M") copyCommand.type = "L";
+		segments = segments.concat(arrayOfLength(segmentCount - 1).map(function() {
+			return copyCommand;
+		}));
+		segments.push(commandEnd);
+	}
+	return segments;
+}
+/**
+* Extends an array of commandsToExtend to the length of the referenceCommands by
+* splitting segments until the number of commands match. Ensures all the actual
+* points of commandsToExtend are in the extended array.
+*
+* @param {Object[]} commandsToExtend The command object array to extend
+* @param {Object[]} referenceCommands The command object array to match in length
+* @param {Function} excludeSegment a function that takes a start command object and
+*   end command object and returns true if the segment should be excluded from splitting.
+* @return {Object[]} The extended commandsToExtend array
+*/
+function extend(commandsToExtend, referenceCommands, excludeSegment) {
+	var numSegmentsToExtend = commandsToExtend.length - 1;
+	var numReferenceSegments = referenceCommands.length - 1;
+	var segmentRatio = numSegmentsToExtend / numReferenceSegments;
+	var extended = arrayOfLength(numReferenceSegments).reduce(function(accum, d, i) {
+		var insertIndex = Math.floor(segmentRatio * i);
+		if (excludeSegment && insertIndex < commandsToExtend.length - 1 && excludeSegment(commandsToExtend[insertIndex], commandsToExtend[insertIndex + 1])) {
+			var addToPriorSegment = segmentRatio * i % 1 < .5;
+			if (accum[insertIndex]) {
+				if (addToPriorSegment) {
+					if (insertIndex > 0) insertIndex -= 1;
+					else if (insertIndex < commandsToExtend.length - 1) insertIndex += 1;
+				} else if (insertIndex < commandsToExtend.length - 1) insertIndex += 1;
+				else if (insertIndex > 0) insertIndex -= 1;
+			}
+		}
+		accum[insertIndex] = (accum[insertIndex] || 0) + 1;
+		return accum;
+	}, []).reduce(function(extended, segmentCount, i) {
+		if (i === commandsToExtend.length - 1) {
+			var lastCommandCopies = arrayOfLength(segmentCount, _extends({}, commandsToExtend[commandsToExtend.length - 1]));
+			if (lastCommandCopies[0].type === "M") lastCommandCopies.forEach(function(d) {
+				d.type = "L";
+			});
+			return extended.concat(lastCommandCopies);
+		}
+		return extended.concat(splitSegment(commandsToExtend[i], commandsToExtend[i + 1], segmentCount));
+	}, []);
+	extended.unshift(commandsToExtend[0]);
+	return extended;
+}
+/**
+* Takes a path `d` string and converts it into an array of command
+* objects. Drops the `Z` character.
+*
+* @param {String|null} d A path `d` string
+*/
+function pathCommandsFromString(d) {
+	var tokens = (d || "").match(commandTokenRegex) || [];
+	var commands = [];
+	var commandArgs;
+	var command;
+	for (var i = 0; i < tokens.length; ++i) {
+		commandArgs = typeMap[tokens[i]];
+		if (commandArgs) {
+			command = { type: tokens[i] };
+			for (var a = 0; a < commandArgs.length; ++a) command[commandArgs[a]] = +tokens[i + a + 1];
+			i += commandArgs.length;
+			commands.push(command);
+		}
+	}
+	return commands;
+}
+/**
+* Interpolate from A to B by extending A and B during interpolation to have
+* the same number of points. This allows for a smooth transition when they
+* have a different number of points.
+*
+* Ignores the `Z` command in paths unless both A and B end with it.
+*
+* This function works directly with arrays of command objects instead of with
+* path `d` strings (see interpolatePath for working with `d` strings).
+*
+* @param {Object[]} aCommandsInput Array of path commands
+* @param {Object[]} bCommandsInput Array of path commands
+* @param {(Function|Object)} interpolateOptions
+* @param {Function} interpolateOptions.excludeSegment a function that takes a start command object and
+*   end command object and returns true if the segment should be excluded from splitting.
+* @param {Boolean} interpolateOptions.snapEndsToInput a boolean indicating whether end of input should
+*   be sourced from input argument or computed.
+* @returns {Function} Interpolation function that maps t ([0, 1]) to an array of path commands.
+*/
+function interpolatePathCommands(aCommandsInput, bCommandsInput, interpolateOptions) {
+	var aCommands = aCommandsInput == null ? [] : aCommandsInput.slice();
+	var bCommands = bCommandsInput == null ? [] : bCommandsInput.slice();
+	var _ref = _typeof(interpolateOptions) === "object" ? interpolateOptions : {
+		excludeSegment: interpolateOptions,
+		snapEndsToInput: true
+	}, excludeSegment = _ref.excludeSegment, snapEndsToInput = _ref.snapEndsToInput;
+	if (!aCommands.length && !bCommands.length) return function nullInterpolator() {
+		return [];
+	};
+	var addZ = (aCommands.length === 0 || aCommands[aCommands.length - 1].type === "Z") && (bCommands.length === 0 || bCommands[bCommands.length - 1].type === "Z");
+	if (aCommands.length > 0 && aCommands[aCommands.length - 1].type === "Z") aCommands.pop();
+	if (bCommands.length > 0 && bCommands[bCommands.length - 1].type === "Z") bCommands.pop();
+	if (!aCommands.length) aCommands.push(bCommands[0]);
+	else if (!bCommands.length) bCommands.push(aCommands[0]);
+	if (Math.abs(bCommands.length - aCommands.length) !== 0) {
+		if (bCommands.length > aCommands.length) aCommands = extend(aCommands, bCommands, excludeSegment);
+		else if (bCommands.length < aCommands.length) bCommands = extend(bCommands, aCommands, excludeSegment);
+	}
+	aCommands = aCommands.map(function(aCommand, i) {
+		return convertToSameType(aCommand, bCommands[i]);
+	});
+	var interpolatedCommands = aCommands.map(function(aCommand) {
+		return _objectSpread2({}, aCommand);
+	});
+	if (addZ) {
+		interpolatedCommands.push({ type: "Z" });
+		aCommands.push({ type: "Z" });
+	}
+	return function pathCommandInterpolator(t) {
+		if (t === 1 && snapEndsToInput) return bCommandsInput == null ? [] : bCommandsInput;
+		if (t === 0) return aCommands;
+		for (var i = 0; i < interpolatedCommands.length; ++i) {
+			var aCommand = aCommands[i];
+			var bCommand = bCommands[i];
+			var interpolatedCommand = interpolatedCommands[i];
+			var _iterator = _createForOfIteratorHelper(typeMap[interpolatedCommand.type]), _step;
+			try {
+				for (_iterator.s(); !(_step = _iterator.n()).done;) {
+					var arg = _step.value;
+					interpolatedCommand[arg] = (1 - t) * aCommand[arg] + t * bCommand[arg];
+					if (arg === "largeArcFlag" || arg === "sweepFlag") interpolatedCommand[arg] = Math.round(interpolatedCommand[arg]);
+				}
+			} catch (err) {
+				_iterator.e(err);
+			} finally {
+				_iterator.f();
+			}
+		}
+		return interpolatedCommands;
+	};
+}
+/** @typedef InterpolateOptions  */
+/**
+* Interpolate from A to B by extending A and B during interpolation to have
+* the same number of points. This allows for a smooth transition when they
+* have a different number of points.
+*
+* Ignores the `Z` character in paths unless both A and B end with it.
+*
+* @param {String} a The `d` attribute for a path
+* @param {String} b The `d` attribute for a path
+* @param {((command1, command2) => boolean|{
+*   excludeSegment?: (command1, command2) => boolean;
+*   snapEndsToInput?: boolean
+* })} interpolateOptions The excludeSegment function or an options object
+*    - interpolateOptions.excludeSegment a function that takes a start command object and
+*      end command object and returns true if the segment should be excluded from splitting.
+*    - interpolateOptions.snapEndsToInput a boolean indicating whether end of input should
+*      be sourced from input argument or computed.
+* @returns {Function} Interpolation function that maps t ([0, 1]) to a path `d` string.
+*/
+function interpolatePath(a, b, interpolateOptions) {
+	var aCommands = pathCommandsFromString(a);
+	var bCommands = pathCommandsFromString(b);
+	var _ref2 = _typeof(interpolateOptions) === "object" ? interpolateOptions : {
+		excludeSegment: interpolateOptions,
+		snapEndsToInput: true
+	}, excludeSegment = _ref2.excludeSegment, snapEndsToInput = _ref2.snapEndsToInput;
+	if (!aCommands.length && !bCommands.length) return function nullInterpolator() {
+		return "";
+	};
+	var commandInterpolator = interpolatePathCommands(aCommands, bCommands, {
+		excludeSegment,
+		snapEndsToInput
+	});
+	return function pathStringInterpolator(t) {
+		if (t === 1 && snapEndsToInput) return b == null ? "" : b;
+		var interpolatedCommands = commandInterpolator(t);
+		var interpolatedString = "";
+		var _iterator2 = _createForOfIteratorHelper(interpolatedCommands), _step2;
+		try {
+			for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+				var interpolatedCommand = _step2.value;
+				interpolatedString += commandToString(interpolatedCommand);
+			}
+		} catch (err) {
+			_iterator2.e(err);
+		} finally {
+			_iterator2.f();
+		}
+		return interpolatedString;
+	};
+}
+//#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/Path/Path.shared.svelte.js
+function resolvePathData(v) {
+	return typeof v === "function" ? v() : v;
+}
+/**
+* Reactive state shared by every per-layer Path variant.
+*/
+var PathState = class {
+	#getPathData;
+	chartCtx = getChartContext();
+	#tweenedState;
+	get tweenedPathData() {
+		return this.#tweenedState.current;
+	}
+	drawKey = Symbol();
+	/**
+	* @param getPathData  Hot-path getter — reads only `pathData`. Kept separate from
+	*                     `getProps` so the `<path d=...>` updater (and the canvas
+	*                     `tweenedPathData` consumer) does not subscribe to every
+	*                     Path prop on every tick.
+	* @param getProps     Full-props getter — used for one-time / cold-path config
+	*                     (motion, draw).
+	*/
+	constructor(getPathData, getProps = () => ({})) {
+		this.#getPathData = () => resolvePathData(getPathData());
+		const initial = getProps();
+		const extractedTween = extractTweenConfig(initial.motion);
+		const tweenedOptions = extractedTween ? {
+			type: extractedTween.type,
+			options: {
+				interpolate: interpolatePath,
+				...extractedTween.options
+			}
+		} : void 0;
+		const defaultPathData = (() => {
+			if (!tweenedOptions) return "";
+			const resolved = resolvePathData(getPathData());
+			if (resolved) return flattenPathData(resolved, Math.min(this.chartCtx.yScale(0) ?? this.chartCtx.yRange[0], this.chartCtx.yRange[0]));
+			return "";
+		})();
+		this.#tweenedState = createMotion(defaultPathData, this.#getPathData, tweenedOptions);
+	}
+};
+//#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/Path/Path.svg.svelte
+function Path_svg($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { pathRef = void 0, marker, markerStart: markerStartProp, markerMid: markerMidProp, markerEnd: markerEndProp, startContent, endContent, draw: draw$1, motion, pathData: _pathData, class: classProp, fill: fillProp, fillOpacity: fillOpacityProp, stroke: strokeProp, strokeOpacity: strokeOpacityProp, strokeWidth: strokeWidthProp, opacity: opacityProp, $$slots, $$events, ...rest } = $$props;
+		const c = new PathState(() => _pathData, () => ({
+			draw: draw$1,
+			motion
+		}));
+		const markerStart = derived(() => markerStartProp ?? marker);
+		const markerMid = derived(() => markerMidProp ?? marker);
+		const markerEnd = derived(() => markerEndProp ?? marker);
+		const markerStartId = derived(() => markerStart() ? createId("marker-start", uid) : "");
+		const markerMidId = derived(() => markerMid() ? createId("marker-mid", uid) : "");
+		const markerEndId = derived(() => markerEnd() ? createId("marker-end", uid) : "");
+		let staticEndPoint = void 0;
+		const pathClass = derived(() => cls("lc-path", classProp));
+		const endPointDuration = derived(() => {
+			if (typeof draw$1 === "object" && draw$1.duration !== void 0 && typeof draw$1.duration !== "function") return draw$1.duration;
+			return 800;
+		});
+		const endPoint = draw$1 && endContent ? createControlledMotion(void 0, {
+			type: "tween",
+			duration: () => endPointDuration(),
+			easing: typeof draw$1 === "object" && draw$1.easing ? draw$1.easing : cubicInOut,
+			interpolate() {
+				return (t) => {
+					const totalLength = pathRef?.getTotalLength() ?? 0;
+					return pathRef?.getPointAtLength(totalLength * t);
+				};
+			}
+		}) : null;
+		const currentEndPoint = derived(() => endPoint ? endPoint.current : staticEndPoint);
+		$$renderer.push(`<!---->`);
+		$$renderer.push(`<path${attributes({
+			...rest,
+			d: c.tweenedPathData,
+			fill: fillProp,
+			"fill-opacity": fillOpacityProp,
+			stroke: strokeProp,
+			"stroke-opacity": strokeOpacityProp,
+			"stroke-width": strokeWidthProp,
+			opacity: opacityProp,
+			class: clsx(pathClass()),
+			"marker-start": markerStartId() ? `url(#${markerStartId()})` : void 0,
+			"marker-mid": markerMidId() ? `url(#${markerMidId()})` : void 0,
+			"marker-end": markerEndId() ? `url(#${markerEndId()})` : void 0
+		}, void 0, void 0, void 0, 3)}></path>`);
+		if (markerStart()) {
+			$$renderer.push("<!--[0-->");
+			MarkerWrapper($$renderer, {
+				id: markerStartId(),
+				marker: markerStart()
+			});
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+		if (markerMid()) {
+			$$renderer.push("<!--[0-->");
+			MarkerWrapper($$renderer, {
+				id: markerMidId(),
+				marker: markerMid()
+			});
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+		if (markerEnd()) {
+			$$renderer.push("<!--[0-->");
+			MarkerWrapper($$renderer, {
+				id: markerEndId(),
+				marker: markerEnd()
+			});
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+		$$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+		if (endContent && currentEndPoint()) {
+			$$renderer.push("<!--[0-->");
+			Group($$renderer, {
+				x: currentEndPoint().x,
+				y: currentEndPoint().y,
+				class: "lc-path-g-end",
+				children: ($$renderer) => {
+					endContent($$renderer, {
+						point: currentEndPoint(),
+						value: {
+							x: c.chartCtx.xScale?.invert?.(currentEndPoint().x),
+							y: c.chartCtx.yScale?.invert?.(currentEndPoint().y)
+						}
+					});
+					$$renderer.push(`<!---->`);
+				},
+				$$slots: { default: true }
+			});
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+		$$renderer.push(`<!---->`);
+		bind_props($$props, { pathRef });
+	});
+}
+//#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/Path/Path.canvas.svelte
+function Path_canvas($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { pathData, $$slots, $$events, ...rest } = $$props;
+		const c = new PathState(() => pathData, () => rest);
+		function render(ctx, styleOverrides) {
+			renderPathData(ctx, c.tweenedPathData ?? "", styleOverrides ? merge({ styles: { strokeWidth: rest.strokeWidth } }, styleOverrides) : {
+				styles: {
+					fill: rest.fill,
+					fillOpacity: rest.fillOpacity,
+					stroke: rest.stroke,
+					strokeOpacity: rest.strokeOpacity,
+					strokeWidth: rest.strokeWidth,
+					opacity: rest.opacity
+				},
+				classes: cls("lc-path", rest.class),
+				style: rest.style
+			});
+		}
+		const fillKey = createKey(() => rest.fill);
+		const strokeKey = createKey(() => rest.stroke);
+		c.chartCtx.registerComponent({
+			name: "Path",
+			kind: "mark",
+			canvasRender: {
+				render,
+				events: {
+					get click() {
+						return rest.onclick;
+					},
+					get pointerenter() {
+						return rest.onpointerenter;
+					},
+					get pointermove() {
+						return rest.onpointermove;
+					},
+					get pointerleave() {
+						return rest.onpointerleave;
+					},
+					get pointerdown() {
+						return rest.onpointerdown;
+					},
+					get pointerover() {
+						return rest.onpointerover;
+					},
+					get pointerout() {
+						return rest.onpointerout;
+					},
+					get touchmove() {
+						return rest.ontouchmove;
+					}
+				},
+				deps: () => [
+					fillKey.current,
+					rest.fillOpacity,
+					strokeKey.current,
+					rest.strokeOpacity,
+					rest.strokeWidth,
+					rest.opacity,
+					rest.class,
+					c.tweenedPathData,
+					rest.style
+				]
+			}
+		});
+	});
+}
+
+export { Group_svg as G, MarkerWrapper as M, Path as P, Path_svg as a, Path_canvas as b, createId as c, Group_canvas as d, Group_html as e, Group as f, fade as g, interpolatePath as i, path as p };
+//# sourceMappingURL=Path.canvas.js-DNAtnEBt.js.map