@webskill/sdk 0.21.0 → 0.22.0

package/dist/chunk-ZIGJFQKS-DqEFBuHR.js

@@ -0,0 +1,2215 @@
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+import { m as log, p as select_default } from "./src-NkhI3UMl.js";
+import { R as sanitizeDirective, h as directiveRegex, p as detectType, r as assignWithDepth_default, s as common_default } from "./chunk-O7XYJQB3-B6K0KOSL.js";
+import { s as epsilon, t as require_dist } from "./dist-UajCDt3n.js";
+
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/linear.js
+function Linear(context) {
+	this._context = context;
+}
+Linear.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._point = 0;
+	},
+	lineEnd: function() {
+		if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+		this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
+				break;
+			case 1: this._point = 2;
+			default:
+				this._context.lineTo(x, y);
+				break;
+		}
+	}
+};
+function linear_default(context) {
+	return new Linear(context);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/bump.js
+var Bump = class {
+	constructor(context, x) {
+		this._context = context;
+		this._x = x;
+	}
+	areaStart() {
+		this._line = 0;
+	}
+	areaEnd() {
+		this._line = NaN;
+	}
+	lineStart() {
+		this._point = 0;
+	}
+	lineEnd() {
+		if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+		this._line = 1 - this._line;
+	}
+	point(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				if (this._line) this._context.lineTo(x, y);
+				else this._context.moveTo(x, y);
+				break;
+			case 1: this._point = 2;
+			default:
+				if (this._x) this._context.bezierCurveTo(this._x0 = (this._x0 + x) / 2, this._y0, this._x0, y, x, y);
+				else this._context.bezierCurveTo(this._x0, this._y0 = (this._y0 + y) / 2, x, this._y0, x, y);
+				break;
+		}
+		this._x0 = x, this._y0 = y;
+	}
+};
+function bumpX(context) {
+	return new Bump(context, true);
+}
+function bumpY(context) {
+	return new Bump(context, false);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/noop.js
+function noop_default() {}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/basis.js
+function point$3(that, x, y) {
+	that._context.bezierCurveTo((2 * that._x0 + that._x1) / 3, (2 * that._y0 + that._y1) / 3, (that._x0 + 2 * that._x1) / 3, (that._y0 + 2 * that._y1) / 3, (that._x0 + 4 * that._x1 + x) / 6, (that._y0 + 4 * that._y1 + y) / 6);
+}
+function Basis(context) {
+	this._context = context;
+}
+Basis.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x0 = this._x1 = this._y0 = this._y1 = NaN;
+		this._point = 0;
+	},
+	lineEnd: function() {
+		switch (this._point) {
+			case 3: point$3(this, this._x1, this._y1);
+			case 2:
+				this._context.lineTo(this._x1, this._y1);
+				break;
+		}
+		if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+		this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
+				break;
+			case 1:
+				this._point = 2;
+				break;
+			case 2:
+				this._point = 3;
+				this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6);
+			default:
+				point$3(this, x, y);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = x;
+		this._y0 = this._y1, this._y1 = y;
+	}
+};
+function basis_default(context) {
+	return new Basis(context);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/basisClosed.js
+function BasisClosed(context) {
+	this._context = context;
+}
+BasisClosed.prototype = {
+	areaStart: noop_default,
+	areaEnd: noop_default,
+	lineStart: function() {
+		this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;
+		this._point = 0;
+	},
+	lineEnd: function() {
+		switch (this._point) {
+			case 1:
+				this._context.moveTo(this._x2, this._y2);
+				this._context.closePath();
+				break;
+			case 2:
+				this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);
+				this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);
+				this._context.closePath();
+				break;
+			case 3:
+				this.point(this._x2, this._y2);
+				this.point(this._x3, this._y3);
+				this.point(this._x4, this._y4);
+				break;
+		}
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._x2 = x, this._y2 = y;
+				break;
+			case 1:
+				this._point = 2;
+				this._x3 = x, this._y3 = y;
+				break;
+			case 2:
+				this._point = 3;
+				this._x4 = x, this._y4 = y;
+				this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6);
+				break;
+			default:
+				point$3(this, x, y);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = x;
+		this._y0 = this._y1, this._y1 = y;
+	}
+};
+function basisClosed_default(context) {
+	return new BasisClosed(context);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/basisOpen.js
+function BasisOpen(context) {
+	this._context = context;
+}
+BasisOpen.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x0 = this._x1 = this._y0 = this._y1 = NaN;
+		this._point = 0;
+	},
+	lineEnd: function() {
+		if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
+		this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				break;
+			case 1:
+				this._point = 2;
+				break;
+			case 2:
+				this._point = 3;
+				var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6;
+				this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0);
+				break;
+			case 3: this._point = 4;
+			default:
+				point$3(this, x, y);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = x;
+		this._y0 = this._y1, this._y1 = y;
+	}
+};
+function basisOpen_default(context) {
+	return new BasisOpen(context);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/bundle.js
+function Bundle(context, beta) {
+	this._basis = new Basis(context);
+	this._beta = beta;
+}
+Bundle.prototype = {
+	lineStart: function() {
+		this._x = [];
+		this._y = [];
+		this._basis.lineStart();
+	},
+	lineEnd: function() {
+		var x = this._x, y = this._y, j = x.length - 1;
+		if (j > 0) {
+			var x0 = x[0], y0 = y[0], dx = x[j] - x0, dy = y[j] - y0, i = -1, t;
+			while (++i <= j) {
+				t = i / j;
+				this._basis.point(this._beta * x[i] + (1 - this._beta) * (x0 + t * dx), this._beta * y[i] + (1 - this._beta) * (y0 + t * dy));
+			}
+		}
+		this._x = this._y = null;
+		this._basis.lineEnd();
+	},
+	point: function(x, y) {
+		this._x.push(+x);
+		this._y.push(+y);
+	}
+};
+var bundle_default = (function custom(beta) {
+	function bundle(context) {
+		return beta === 1 ? new Basis(context) : new Bundle(context, beta);
+	}
+	bundle.beta = function(beta) {
+		return custom(+beta);
+	};
+	return bundle;
+})(.85);
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/cardinal.js
+function point$2(that, x, y) {
+	that._context.bezierCurveTo(that._x1 + that._k * (that._x2 - that._x0), that._y1 + that._k * (that._y2 - that._y0), that._x2 + that._k * (that._x1 - x), that._y2 + that._k * (that._y1 - y), that._x2, that._y2);
+}
+function Cardinal(context, tension) {
+	this._context = context;
+	this._k = (1 - tension) / 6;
+}
+Cardinal.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+		this._point = 0;
+	},
+	lineEnd: function() {
+		switch (this._point) {
+			case 2:
+				this._context.lineTo(this._x2, this._y2);
+				break;
+			case 3:
+				point$2(this, this._x1, this._y1);
+				break;
+		}
+		if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+		this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
+				break;
+			case 1:
+				this._point = 2;
+				this._x1 = x, this._y1 = y;
+				break;
+			case 2: this._point = 3;
+			default:
+				point$2(this, x, y);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
+		this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
+	}
+};
+var cardinal_default = (function custom(tension) {
+	function cardinal(context) {
+		return new Cardinal(context, tension);
+	}
+	cardinal.tension = function(tension) {
+		return custom(+tension);
+	};
+	return cardinal;
+})(0);
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/cardinalClosed.js
+function CardinalClosed(context, tension) {
+	this._context = context;
+	this._k = (1 - tension) / 6;
+}
+CardinalClosed.prototype = {
+	areaStart: noop_default,
+	areaEnd: noop_default,
+	lineStart: function() {
+		this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;
+		this._point = 0;
+	},
+	lineEnd: function() {
+		switch (this._point) {
+			case 1:
+				this._context.moveTo(this._x3, this._y3);
+				this._context.closePath();
+				break;
+			case 2:
+				this._context.lineTo(this._x3, this._y3);
+				this._context.closePath();
+				break;
+			case 3:
+				this.point(this._x3, this._y3);
+				this.point(this._x4, this._y4);
+				this.point(this._x5, this._y5);
+				break;
+		}
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._x3 = x, this._y3 = y;
+				break;
+			case 1:
+				this._point = 2;
+				this._context.moveTo(this._x4 = x, this._y4 = y);
+				break;
+			case 2:
+				this._point = 3;
+				this._x5 = x, this._y5 = y;
+				break;
+			default:
+				point$2(this, x, y);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
+		this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
+	}
+};
+var cardinalClosed_default = (function custom(tension) {
+	function cardinal(context) {
+		return new CardinalClosed(context, tension);
+	}
+	cardinal.tension = function(tension) {
+		return custom(+tension);
+	};
+	return cardinal;
+})(0);
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/cardinalOpen.js
+function CardinalOpen(context, tension) {
+	this._context = context;
+	this._k = (1 - tension) / 6;
+}
+CardinalOpen.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+		this._point = 0;
+	},
+	lineEnd: function() {
+		if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
+		this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				break;
+			case 1:
+				this._point = 2;
+				break;
+			case 2:
+				this._point = 3;
+				this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);
+				break;
+			case 3: this._point = 4;
+			default:
+				point$2(this, x, y);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
+		this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
+	}
+};
+var cardinalOpen_default = (function custom(tension) {
+	function cardinal(context) {
+		return new CardinalOpen(context, tension);
+	}
+	cardinal.tension = function(tension) {
+		return custom(+tension);
+	};
+	return cardinal;
+})(0);
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/catmullRom.js
+function point$1(that, x, y) {
+	var x1 = that._x1, y1 = that._y1, x2 = that._x2, y2 = that._y2;
+	if (that._l01_a > 1e-12) {
+		var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a, n = 3 * that._l01_a * (that._l01_a + that._l12_a);
+		x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;
+		y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;
+	}
+	if (that._l23_a > 1e-12) {
+		var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a, m = 3 * that._l23_a * (that._l23_a + that._l12_a);
+		x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;
+		y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;
+	}
+	that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);
+}
+function CatmullRom(context, alpha) {
+	this._context = context;
+	this._alpha = alpha;
+}
+CatmullRom.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+		this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+	},
+	lineEnd: function() {
+		switch (this._point) {
+			case 2:
+				this._context.lineTo(this._x2, this._y2);
+				break;
+			case 3:
+				this.point(this._x2, this._y2);
+				break;
+		}
+		if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+		this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		if (this._point) {
+			var x23 = this._x2 - x, y23 = this._y2 - y;
+			this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
+		}
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
+				break;
+			case 1:
+				this._point = 2;
+				break;
+			case 2: this._point = 3;
+			default:
+				point$1(this, x, y);
+				break;
+		}
+		this._l01_a = this._l12_a, this._l12_a = this._l23_a;
+		this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
+		this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
+	}
+};
+var catmullRom_default = (function custom(alpha) {
+	function catmullRom(context) {
+		return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);
+	}
+	catmullRom.alpha = function(alpha) {
+		return custom(+alpha);
+	};
+	return catmullRom;
+})(.5);
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/catmullRomClosed.js
+function CatmullRomClosed(context, alpha) {
+	this._context = context;
+	this._alpha = alpha;
+}
+CatmullRomClosed.prototype = {
+	areaStart: noop_default,
+	areaEnd: noop_default,
+	lineStart: function() {
+		this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;
+		this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+	},
+	lineEnd: function() {
+		switch (this._point) {
+			case 1:
+				this._context.moveTo(this._x3, this._y3);
+				this._context.closePath();
+				break;
+			case 2:
+				this._context.lineTo(this._x3, this._y3);
+				this._context.closePath();
+				break;
+			case 3:
+				this.point(this._x3, this._y3);
+				this.point(this._x4, this._y4);
+				this.point(this._x5, this._y5);
+				break;
+		}
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		if (this._point) {
+			var x23 = this._x2 - x, y23 = this._y2 - y;
+			this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
+		}
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._x3 = x, this._y3 = y;
+				break;
+			case 1:
+				this._point = 2;
+				this._context.moveTo(this._x4 = x, this._y4 = y);
+				break;
+			case 2:
+				this._point = 3;
+				this._x5 = x, this._y5 = y;
+				break;
+			default:
+				point$1(this, x, y);
+				break;
+		}
+		this._l01_a = this._l12_a, this._l12_a = this._l23_a;
+		this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
+		this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
+	}
+};
+var catmullRomClosed_default = (function custom(alpha) {
+	function catmullRom(context) {
+		return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);
+	}
+	catmullRom.alpha = function(alpha) {
+		return custom(+alpha);
+	};
+	return catmullRom;
+})(.5);
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/catmullRomOpen.js
+function CatmullRomOpen(context, alpha) {
+	this._context = context;
+	this._alpha = alpha;
+}
+CatmullRomOpen.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+		this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+	},
+	lineEnd: function() {
+		if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
+		this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		if (this._point) {
+			var x23 = this._x2 - x, y23 = this._y2 - y;
+			this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
+		}
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				break;
+			case 1:
+				this._point = 2;
+				break;
+			case 2:
+				this._point = 3;
+				this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);
+				break;
+			case 3: this._point = 4;
+			default:
+				point$1(this, x, y);
+				break;
+		}
+		this._l01_a = this._l12_a, this._l12_a = this._l23_a;
+		this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
+		this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
+	}
+};
+var catmullRomOpen_default = (function custom(alpha) {
+	function catmullRom(context) {
+		return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);
+	}
+	catmullRom.alpha = function(alpha) {
+		return custom(+alpha);
+	};
+	return catmullRom;
+})(.5);
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/linearClosed.js
+function LinearClosed(context) {
+	this._context = context;
+}
+LinearClosed.prototype = {
+	areaStart: noop_default,
+	areaEnd: noop_default,
+	lineStart: function() {
+		this._point = 0;
+	},
+	lineEnd: function() {
+		if (this._point) this._context.closePath();
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		if (this._point) this._context.lineTo(x, y);
+		else this._point = 1, this._context.moveTo(x, y);
+	}
+};
+function linearClosed_default(context) {
+	return new LinearClosed(context);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/monotone.js
+function sign(x) {
+	return x < 0 ? -1 : 1;
+}
+function slope3(that, x2, y2) {
+	var h0 = that._x1 - that._x0, h1 = x2 - that._x1, s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0), s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0), 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;
+}
+function slope2(that, t) {
+	var h = that._x1 - that._x0;
+	return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;
+}
+function point(that, t0, t1) {
+	var x0 = that._x0, y0 = that._y0, x1 = that._x1, y1 = that._y1, dx = (x1 - x0) / 3;
+	that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);
+}
+function MonotoneX(context) {
+	this._context = context;
+}
+MonotoneX.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN;
+		this._point = 0;
+	},
+	lineEnd: function() {
+		switch (this._point) {
+			case 2:
+				this._context.lineTo(this._x1, this._y1);
+				break;
+			case 3:
+				point(this, this._t0, slope2(this, this._t0));
+				break;
+		}
+		if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+		this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		var t1 = NaN;
+		x = +x, y = +y;
+		if (x === this._x1 && y === this._y1) return;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
+				break;
+			case 1:
+				this._point = 2;
+				break;
+			case 2:
+				this._point = 3;
+				point(this, slope2(this, t1 = slope3(this, x, y)), t1);
+				break;
+			default:
+				point(this, this._t0, t1 = slope3(this, x, y));
+				break;
+		}
+		this._x0 = this._x1, this._x1 = x;
+		this._y0 = this._y1, this._y1 = y;
+		this._t0 = t1;
+	}
+};
+function MonotoneY(context) {
+	this._context = new ReflectContext(context);
+}
+(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {
+	MonotoneX.prototype.point.call(this, y, x);
+};
+function ReflectContext(context) {
+	this._context = context;
+}
+ReflectContext.prototype = {
+	moveTo: function(x, y) {
+		this._context.moveTo(y, x);
+	},
+	closePath: function() {
+		this._context.closePath();
+	},
+	lineTo: function(x, y) {
+		this._context.lineTo(y, x);
+	},
+	bezierCurveTo: function(x1, y1, x2, y2, x, y) {
+		this._context.bezierCurveTo(y1, x1, y2, x2, y, x);
+	}
+};
+function monotoneX(context) {
+	return new MonotoneX(context);
+}
+function monotoneY(context) {
+	return new MonotoneY(context);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/natural.js
+function Natural(context) {
+	this._context = context;
+}
+Natural.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x = [];
+		this._y = [];
+	},
+	lineEnd: function() {
+		var x = this._x, y = this._y, n = x.length;
+		if (n) {
+			this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]);
+			if (n === 2) this._context.lineTo(x[1], y[1]);
+			else {
+				var px = controlPoints(x), py = controlPoints(y);
+				for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);
+			}
+		}
+		if (this._line || this._line !== 0 && n === 1) this._context.closePath();
+		this._line = 1 - this._line;
+		this._x = this._y = null;
+	},
+	point: function(x, y) {
+		this._x.push(+x);
+		this._y.push(+y);
+	}
+};
+function controlPoints(x) {
+	var i, n = x.length - 1, m, a = new Array(n), b = new Array(n), r = new Array(n);
+	a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1];
+	for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];
+	a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n];
+	for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];
+	a[n - 1] = r[n - 1] / b[n - 1];
+	for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];
+	b[n - 1] = (x[n] + a[n - 1]) / 2;
+	for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1];
+	return [a, b];
+}
+function natural_default(context) {
+	return new Natural(context);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/step.js
+function Step(context, t) {
+	this._context = context;
+	this._t = t;
+}
+Step.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x = this._y = NaN;
+		this._point = 0;
+	},
+	lineEnd: function() {
+		if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);
+		if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+		if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;
+	},
+	point: function(x, y) {
+		x = +x, y = +y;
+		switch (this._point) {
+			case 0:
+				this._point = 1;
+				this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
+				break;
+			case 1: this._point = 2;
+			default:
+				if (this._t <= 0) {
+					this._context.lineTo(this._x, y);
+					this._context.lineTo(x, y);
+				} else {
+					var x1 = this._x * (1 - this._t) + x * this._t;
+					this._context.lineTo(x1, this._y);
+					this._context.lineTo(x1, y);
+				}
+				break;
+		}
+		this._x = x, this._y = y;
+	}
+};
+function step_default(context) {
+	return new Step(context, .5);
+}
+function stepBefore(context) {
+	return new Step(context, 0);
+}
+function stepAfter(context) {
+	return new Step(context, 1);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.mjs
+/**
+* Checks if a given value is a plain object.
+*
+* A plain object is an object created by the `{}` literal, `new Object()`, or
+* `Object.create(null)`.
+*
+* This function also handles objects with custom
+* `Symbol.toStringTag` properties.
+*
+* `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the
+* default string description of objects.
+*
+* @param [object] - The value to check.
+* @returns True if the value is a plain object, otherwise false.
+*
+* @example
+* console.log(isPlainObject({})); // true
+* console.log(isPlainObject([])); // false
+* console.log(isPlainObject(null)); // false
+* console.log(isPlainObject(Object.create(null))); // true
+* console.log(isPlainObject(new Map())); // false
+*/
+function isPlainObject(object) {
+	if (typeof object !== "object") return false;
+	if (object == null) return false;
+	if (Object.getPrototypeOf(object) === null) return true;
+	if (Object.prototype.toString.call(object) !== "[object Object]") {
+		const tag = object[Symbol.toStringTag];
+		if (tag == null) return false;
+		if (!Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable) return false;
+		return object.toString() === `[object ${tag}]`;
+	}
+	let proto = object;
+	while (Object.getPrototypeOf(proto) !== null) proto = Object.getPrototypeOf(proto);
+	return Object.getPrototypeOf(object) === proto;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/function/noop.mjs
+/**
+* A no-operation function that does nothing.
+* This can be used as a placeholder or default function.
+*
+* @example
+* noop(); // Does nothing
+*
+* @returns This function does not return anything.
+*/
+function noop() {}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function getSymbols(object) {
+	return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+/**
+* Gets the `toStringTag` of `value`.
+*
+* @private
+* @param {T} value The value to query.
+* @returns {string} Returns the `Object.prototype.toString.call` result.
+*/
+function getTag(value) {
+	if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
+	return Object.prototype.toString.call(value);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+const regexpTag = "[object RegExp]";
+const stringTag = "[object String]";
+const numberTag = "[object Number]";
+const booleanTag = "[object Boolean]";
+const argumentsTag = "[object Arguments]";
+const symbolTag = "[object Symbol]";
+const dateTag = "[object Date]";
+const mapTag = "[object Map]";
+const setTag = "[object Set]";
+const arrayTag = "[object Array]";
+const arrayBufferTag = "[object ArrayBuffer]";
+const objectTag = "[object Object]";
+const dataViewTag = "[object DataView]";
+const uint8ArrayTag = "[object Uint8Array]";
+const uint8ClampedArrayTag = "[object Uint8ClampedArray]";
+const uint16ArrayTag = "[object Uint16Array]";
+const uint32ArrayTag = "[object Uint32Array]";
+const int8ArrayTag = "[object Int8Array]";
+const int16ArrayTag = "[object Int16Array]";
+const int32ArrayTag = "[object Int32Array]";
+const float32ArrayTag = "[object Float32Array]";
+const float64ArrayTag = "[object Float64Array]";
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/_internal/globalThis.mjs
+const globalThis_ = typeof globalThis === "object" && globalThis || typeof window === "object" && window || typeof self === "object" && self || typeof global === "object" && global || (function() {
+	return this;
+})();
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isBuffer.mjs
+/**
+* Checks if the given value is a Buffer instance.
+*
+* This function tests whether the provided value is an instance of Buffer.
+* It returns `true` if the value is a Buffer, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
+*
+* @param x - The value to check if it is a Buffer.
+* @returns Returns `true` if `x` is a Buffer, else `false`.
+*
+* @example
+* const buffer = Buffer.from("test");
+* console.log(isBuffer(buffer)); // true
+*
+* const notBuffer = "not a buffer";
+* console.log(isBuffer(notBuffer)); // false
+*/
+function isBuffer(x) {
+	return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isLength.mjs
+/**
+* Checks if a given value is a valid length.
+*
+* A valid length is of type `number`, is a non-negative integer, and is less than or equal to
+* JavaScript's maximum safe integer (`Number.MAX_SAFE_INTEGER`).
+* It returns `true` if the value is a valid length, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the
+* argument to a valid length (`number`).
+*
+* @param value The value to check.
+* @returns Returns `true` if `value` is a valid length, else `false`.
+*
+* @example
+* isLength(0); // true
+* isLength(42); // true
+* isLength(-1); // false
+* isLength(1.5); // false
+* isLength(Number.MAX_SAFE_INTEGER); // true
+* isLength(Number.MAX_SAFE_INTEGER + 1); // false
+*/
+function isLength(value) {
+	return Number.isSafeInteger(value) && value >= 0;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.mjs
+/**
+* Checks if `value` is array-like.
+*
+* @param value The value to check.
+* @returns Returns `true` if `value` is array-like, else `false`.
+*
+* @example
+* isArrayLike([1, 2, 3]); // true
+* isArrayLike('abc'); // true
+* isArrayLike({ 0: 'a', length: 1 }); // true
+* isArrayLike({}); // false
+* isArrayLike(null); // false
+* isArrayLike(undefined); // false
+*/
+function isArrayLike(value) {
+	return value != null && typeof value !== "function" && isLength(value.length);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+/**
+* Checks if a property key is unsafe to modify directly.
+*
+* This function is used in functions like `merge` to prevent prototype pollution attacks
+* by identifying property keys that could modify the object's prototype chain or constructor.
+*
+* @param key - The property key to check
+* @returns `true` if the property is unsafe to modify directly, `false` otherwise
+* @internal
+*/
+function isUnsafeProperty(key) {
+	return key === "__proto__";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
+/**
+* Checks whether a value is a JavaScript primitive.
+* JavaScript primitives include null, undefined, strings, numbers, booleans, symbols, and bigints.
+*
+* @param value The value to check.
+* @returns Returns true if `value` is a primitive, false otherwise.
+*
+* @example
+* isPrimitive(null); // true
+* isPrimitive(undefined); // true
+* isPrimitive('123'); // true
+* isPrimitive(false); // true
+* isPrimitive(true); // true
+* isPrimitive(Symbol('a')); // true
+* isPrimitive(123n); // true
+* isPrimitive({}); // false
+* isPrimitive(new Date()); // false
+* isPrimitive(new Map()); // false
+* isPrimitive(new Set()); // false
+* isPrimitive([1, 2, 3]); // false
+*/
+function isPrimitive(value) {
+	return value == null || typeof value !== "object" && typeof value !== "function";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
+/**
+* Checks if a value is a TypedArray.
+* @param x The value to check.
+* @returns Returns true if `x` is a TypedArray, false otherwise.
+*
+* @example
+* const arr = new Uint8Array([1, 2, 3]);
+* isTypedArray(arr); // true
+*
+* const regularArray = [1, 2, 3];
+* isTypedArray(regularArray); // false
+*
+* const buffer = new ArrayBuffer(16);
+* isTypedArray(buffer); // false
+*/
+function isTypedArray$1(x) {
+	return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
+/**
+* Deeply clones the given object.
+*
+* You can customize the deep cloning process using the `cloneValue` function.
+* The function takes the current value `value`, the property name `key`, and the entire object `obj` as arguments.
+* If the function returns a value, that value is used;
+* if it returns `undefined`, the default cloning method is used.
+*
+* @template T - The type of the object.
+* @param obj - The object to clone.
+* @param [cloneValue] - A function to customize the cloning process.
+* @returns A deep clone of the given object.
+*
+* @example
+* // Clone a primitive value
+* const num = 29;
+* const clonedNum = cloneDeepWith(num);
+* console.log(clonedNum); // 29
+* console.log(clonedNum === num); // true
+*
+* @example
+* // Clone an object with a customizer
+* const obj = { a: 1, b: 2 };
+* const clonedObj = cloneDeepWith(obj, (value) => {
+*   if (typeof value === 'number') {
+*     return value * 2; // Double the number
+*   }
+* });
+* console.log(clonedObj); // { a: 2, b: 4 }
+* console.log(clonedObj === obj); // false
+*
+* @example
+* // Clone an array with a customizer
+* const arr = [1, 2, 3];
+* const clonedArr = cloneDeepWith(arr, (value) => {
+*   return value + 1; // Increment each value
+* });
+* console.log(clonedArr); // [2, 3, 4]
+* console.log(clonedArr === arr); // false
+*/
+function cloneDeepWith$1(obj, cloneValue) {
+	return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), cloneValue);
+}
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
+	const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+	if (cloned !== void 0) return cloned;
+	if (isPrimitive(valueToClone)) return valueToClone;
+	if (stack.has(valueToClone)) return stack.get(valueToClone);
+	if (Array.isArray(valueToClone)) {
+		const result = new Array(valueToClone.length);
+		stack.set(valueToClone, result);
+		for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+		if (Object.hasOwn(valueToClone, "index")) result.index = valueToClone.index;
+		if (Object.hasOwn(valueToClone, "input")) result.input = valueToClone.input;
+		return result;
+	}
+	if (valueToClone instanceof Date) return new Date(valueToClone.getTime());
+	if (valueToClone instanceof RegExp) {
+		const result = new RegExp(valueToClone.source, valueToClone.flags);
+		result.lastIndex = valueToClone.lastIndex;
+		return result;
+	}
+	if (valueToClone instanceof Map) {
+		const result = /* @__PURE__ */ new Map();
+		stack.set(valueToClone, result);
+		for (const [key, value] of valueToClone) result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+		return result;
+	}
+	if (valueToClone instanceof Set) {
+		const result = /* @__PURE__ */ new Set();
+		stack.set(valueToClone, result);
+		for (const value of valueToClone) result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
+		return result;
+	}
+	if (isBuffer(valueToClone)) return valueToClone.subarray();
+	if (isTypedArray$1(valueToClone)) {
+		const result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
+		stack.set(valueToClone, result);
+		for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+		return result;
+	}
+	if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && valueToClone instanceof SharedArrayBuffer) return valueToClone.slice(0);
+	if (valueToClone instanceof DataView) {
+		const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+		stack.set(valueToClone, result);
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+		return result;
+	}
+	if (typeof File !== "undefined" && valueToClone instanceof File) {
+		const result = new File([valueToClone], valueToClone.name, { type: valueToClone.type });
+		stack.set(valueToClone, result);
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+		return result;
+	}
+	if (typeof Blob !== "undefined" && valueToClone instanceof Blob) {
+		const result = new Blob([valueToClone], { type: valueToClone.type });
+		stack.set(valueToClone, result);
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+		return result;
+	}
+	if (valueToClone instanceof Error) {
+		const result = structuredClone(valueToClone);
+		stack.set(valueToClone, result);
+		result.message = valueToClone.message;
+		result.name = valueToClone.name;
+		result.stack = valueToClone.stack;
+		result.cause = valueToClone.cause;
+		result.constructor = valueToClone.constructor;
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+		return result;
+	}
+	if (valueToClone instanceof Boolean) {
+		const result = new Boolean(valueToClone.valueOf());
+		stack.set(valueToClone, result);
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+		return result;
+	}
+	if (valueToClone instanceof Number) {
+		const result = new Number(valueToClone.valueOf());
+		stack.set(valueToClone, result);
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+		return result;
+	}
+	if (valueToClone instanceof String) {
+		const result = new String(valueToClone.valueOf());
+		stack.set(valueToClone, result);
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+		return result;
+	}
+	if (typeof valueToClone === "object" && isCloneableObject(valueToClone)) {
+		const result = Object.create(Object.getPrototypeOf(valueToClone));
+		stack.set(valueToClone, result);
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+		return result;
+	}
+	return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+	const keys = [...Object.keys(source), ...getSymbols(source)];
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const descriptor = Object.getOwnPropertyDescriptor(target, key);
+		if (descriptor == null || descriptor.writable) target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+	}
+}
+function isCloneableObject(object) {
+	switch (getTag(object)) {
+		case argumentsTag:
+		case arrayTag:
+		case arrayBufferTag:
+		case dataViewTag:
+		case booleanTag:
+		case dateTag:
+		case float32ArrayTag:
+		case float64ArrayTag:
+		case int8ArrayTag:
+		case int16ArrayTag:
+		case int32ArrayTag:
+		case mapTag:
+		case numberTag:
+		case objectTag:
+		case regexpTag:
+		case setTag:
+		case stringTag:
+		case symbolTag:
+		case uint8ArrayTag:
+		case uint8ClampedArrayTag:
+		case uint16ArrayTag:
+		case uint32ArrayTag: return true;
+		default: return false;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.mjs
+/**
+* Creates a deep clone of the given object using a customizer function.
+*
+* @template T - The type of the object.
+* @param obj - The object to clone.
+* @param [cloneValue] - A function to customize the cloning process.
+* @returns A deep clone of the given object.
+*
+* @example
+* // Clone a primitive value
+* const num = 29;
+* const clonedNum = cloneDeepWith(num);
+* console.log(clonedNum); // 29
+* console.log(clonedNum === num); // true
+*
+* @example
+* // Clone an object with a customizer
+* const obj = { a: 1, b: 2 };
+* const clonedObj = cloneDeepWith(obj, (value) => {
+*   if (typeof value === 'number') {
+*     return value * 2; // Double the number
+*   }
+* });
+* console.log(clonedObj); // { a: 2, b: 4 }
+* console.log(clonedObj === obj); // false
+*
+* @example
+* // Clone an array with a customizer
+* const arr = [1, 2, 3];
+* const clonedArr = cloneDeepWith(arr, (value) => {
+*   return value + 1; // Increment each value
+* });
+* console.log(clonedArr); // [2, 3, 4]
+* console.log(clonedArr === arr); // false
+*/
+function cloneDeepWith(obj, customizer) {
+	return cloneDeepWith$1(obj, (value, key, object, stack) => {
+		const cloned = customizer?.(value, key, object, stack);
+		if (cloned !== void 0) return cloned;
+		if (typeof obj !== "object") return;
+		if (getTag(obj) === "[object Object]" && typeof obj.constructor !== "function") {
+			const result = {};
+			stack.set(obj, result);
+			copyProperties(result, obj, object, stack);
+			return result;
+		}
+		switch (Object.prototype.toString.call(obj)) {
+			case numberTag:
+			case stringTag:
+			case booleanTag: {
+				const result = new obj.constructor(obj?.valueOf());
+				copyProperties(result, obj);
+				return result;
+			}
+			case argumentsTag: {
+				const result = {};
+				copyProperties(result, obj);
+				result.length = obj.length;
+				result[Symbol.iterator] = obj[Symbol.iterator];
+				return result;
+			}
+			default: return;
+		}
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/object/cloneDeep.mjs
+/**
+* Creates a deep clone of the given object.
+*
+* @template T - The type of the object.
+* @param obj - The object to clone.
+* @returns A deep clone of the given object.
+*
+* @example
+* // Clone a primitive value
+* const num = 29;
+* const clonedNum = clone(num);
+* console.log(clonedNum); // 29
+* console.log(clonedNum === num); // true
+*
+* @example
+* // Clone an array
+* const arr = [1, 2, 3];
+* const clonedArr = clone(arr);
+* console.log(clonedArr); // [1, 2, 3]
+* console.log(clonedArr === arr); // false
+*
+* @example
+* // Clone an array with nested objects
+* const arr = [1, { a: 1 }, [1, 2, 3]];
+* const clonedArr = clone(arr);
+* arr[1].a = 2;
+* console.log(arr); // [2, { a: 2 }, [1, 2, 3]]
+* console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]]
+* console.log(clonedArr === arr); // false
+*
+* @example
+* // Clone an object
+* const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+* const clonedObj = clone(obj);
+* console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+* console.log(clonedObj === obj); // false
+*
+* @example
+* // Clone an object with nested objects
+* const obj = { a: 1, b: { c: 1 } };
+* const clonedObj = clone(obj);
+* obj.b.c = 2;
+* console.log(obj); // { a: 1, b: { c: 2 } }
+* console.log(clonedObj); // { a: 1, b: { c: 1 } }
+* console.log(clonedObj === obj); // false
+*/
+function cloneDeep(obj) {
+	return cloneDeepWith(obj);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/predicate/isArguments.mjs
+/**
+* Checks if the given value is an arguments object.
+*
+* This function tests whether the provided value is an arguments object or not.
+* It returns `true` if the value is an arguments object, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an arguments object.
+*
+* @param value - The value to test if it is an arguments object.
+* @returns `true` if the value is an arguments, `false` otherwise.
+*
+* @example
+* const args = (function() { return arguments; })();
+* const strictArgs = (function() { 'use strict'; return arguments; })();
+* const value = [1, 2, 3];
+*
+* console.log(isArguments(args)); // true
+* console.log(isArguments(strictArgs)); // true
+* console.log(isArguments(value)); // false
+*/
+function isArguments(value) {
+	return value !== null && typeof value === "object" && getTag(value) === "[object Arguments]";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.mjs
+/**
+* Checks if the given value is object-like.
+*
+* A value is object-like if its type is object and it is not null.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object-like value.
+*
+* @param value - The value to test if it is an object-like.
+* @returns `true` if the value is an object-like, `false` otherwise.
+*
+* @example
+* const value1 = { a: 1 };
+* const value2 = [1, 2, 3];
+* const value3 = 'abc';
+* const value4 = () => {};
+* const value5 = null;
+*
+* console.log(isObjectLike(value1)); // true
+* console.log(isObjectLike(value2)); // true
+* console.log(isObjectLike(value3)); // false
+* console.log(isObjectLike(value4)); // false
+* console.log(isObjectLike(value5)); // false
+*/
+function isObjectLike(value) {
+	return typeof value === "object" && value !== null;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.mjs
+/**
+* Checks if the given value is a non-primitive, array-like object.
+*
+* @param value The value to check.
+* @returns `true` if the value is a non-primitive, array-like object, `false` otherwise.
+*
+* @example
+* isArrayLikeObject([1, 2, 3]); // true
+* isArrayLikeObject({ 0: 'a', length: 1 }); // true
+* isArrayLikeObject('abc'); // false
+* isArrayLikeObject(()=>{}); // false
+*/
+function isArrayLikeObject(value) {
+	return isObjectLike(value) && isArrayLike(value);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.mjs
+/**
+* Checks if a value is a TypedArray.
+* @param x The value to check.
+* @returns Returns true if `x` is a TypedArray, false otherwise.
+*
+* @example
+* const arr = new Uint8Array([1, 2, 3]);
+* isTypedArray(arr); // true
+*
+* const regularArray = [1, 2, 3];
+* isTypedArray(regularArray); // false
+*
+* const buffer = new ArrayBuffer(16);
+* isTypedArray(buffer); // false
+*/
+function isTypedArray(x) {
+	return isTypedArray$1(x);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/function/memoize.mjs
+/**
+* Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for
+* storing the result based on the arguments provided to the memoized function. By default, the first argument
+* provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with
+* the this binding of the memoized function.
+*
+* @template T - The type of the original function being memoized
+* @param func The function to have its output memoized.
+* @param [resolver] The function to resolve the cache key.
+* @return {MemoizedFunction<T>} Returns the new memoizing function.
+*/
+function memoize(func, resolver) {
+	if (typeof func !== "function" || resolver != null && typeof resolver !== "function") throw new TypeError("Expected a function");
+	const memoized = function(...args) {
+		const key = resolver ? resolver.apply(this, args) : args[0];
+		const cache = memoized.cache;
+		if (cache.has(key)) return cache.get(key);
+		const result = func.apply(this, args);
+		memoized.cache = cache.set(key, result) || cache;
+		return result;
+	};
+	memoized.cache = new (memoize.Cache || Map)();
+	return memoized;
+}
+memoize.Cache = Map;
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/object/clone.mjs
+/**
+* Creates a shallow clone of the given object.
+*
+* @template T - The type of the object.
+* @param obj - The object to clone.
+* @returns A shallow clone of the given object.
+*
+* @example
+* // Clone a primitive value
+* const num = 29;
+* const clonedNum = clone(num);
+* console.log(clonedNum); // 29
+* console.log(clonedNum === num); // true
+*
+* @example
+* // Clone an array
+* const arr = [1, 2, 3];
+* const clonedArr = clone(arr);
+* console.log(clonedArr); // [1, 2, 3]
+* console.log(clonedArr === arr); // false
+*
+* @example
+* // Clone an object
+* const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+* const clonedObj = clone(obj);
+* console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+* console.log(clonedObj === obj); // false
+*/
+function clone(obj) {
+	if (isPrimitive(obj)) return obj;
+	if (Array.isArray(obj) || isTypedArray$1(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && obj instanceof SharedArrayBuffer) return obj.slice(0);
+	const prototype = Object.getPrototypeOf(obj);
+	if (prototype == null) return Object.assign(Object.create(prototype), obj);
+	const Constructor = prototype.constructor;
+	if (obj instanceof Date || obj instanceof Map || obj instanceof Set) return new Constructor(obj);
+	if (obj instanceof RegExp) {
+		const newRegExp = new Constructor(obj);
+		newRegExp.lastIndex = obj.lastIndex;
+		return newRegExp;
+	}
+	if (obj instanceof DataView) return new Constructor(obj.buffer.slice(0));
+	if (obj instanceof Error) {
+		let newError;
+		if (obj instanceof AggregateError) newError = new Constructor(obj.errors, obj.message, { cause: obj.cause });
+		else newError = new Constructor(obj.message, { cause: obj.cause });
+		newError.stack = obj.stack;
+		Object.assign(newError, obj);
+		return newError;
+	}
+	if (typeof File !== "undefined" && obj instanceof File) return new Constructor([obj], obj.name, {
+		type: obj.type,
+		lastModified: obj.lastModified
+	});
+	if (typeof obj === "object") return Object.assign(Object.create(prototype), obj);
+	return obj;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/object/mergeWith.mjs
+/**
+* Merges the properties of one or more source objects into the target object using a customizer function.
+*
+* This function performs a deep merge, recursively merging nested objects and arrays.
+* If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+* If a property in the source object is `undefined`, it will not overwrite a defined property in the target object.
+*
+* You can provide a custom `merge` function to control how properties are merged. The `merge` function is called for each property that is being merged and receives the following arguments:
+*
+* - `targetValue`: The current value of the property in the target object.
+* - `sourceValue`: The value of the property in the source object.
+* - `key`: The key of the property being merged.
+* - `target`: The target object.
+* - `source`: The source object.
+* - `stack`: A `Map` used to keep track of objects that have already been processed to handle circular references.
+*
+* The `merge` function should return the value to be set in the target object. If it returns `undefined`, a default deep merge will be applied for arrays and objects.
+*
+* The function can handle multiple source objects and will merge them all into the target object.
+*
+* @param object - The target object into which the source object properties will be merged. This object is modified in place.
+* @param otherArgs - Additional source objects to merge into the target object, including the custom `merge` function.
+* @returns The updated target object with properties from the source object(s) merged in.
+*
+* @example
+* const target = { a: 1, b: 2 };
+* const source = { b: 3, c: 4 };
+*
+* mergeWith(target, source, (targetValue, sourceValue) => {
+*   if (typeof targetValue === 'number' && typeof sourceValue === 'number') {
+*     return targetValue + sourceValue;
+*   }
+* });
+* // Returns { a: 1, b: 5, c: 4 }
+* @example
+* const target = { a: [1], b: [2] };
+* const source = { a: [3], b: [4] };
+*
+* const result = mergeWith(target, source, (objValue, srcValue) => {
+*   if (Array.isArray(objValue)) {
+*     return objValue.concat(srcValue);
+*   }
+* });
+*
+* expect(result).toEqual({ a: [1, 3], b: [2, 4] });
+*/
+function mergeWith(object, ...otherArgs) {
+	const sources = otherArgs.slice(0, -1);
+	const merge = otherArgs[otherArgs.length - 1];
+	let result = object;
+	for (let i = 0; i < sources.length; i++) {
+		const source = sources[i];
+		result = mergeWithDeep(result, source, merge, /* @__PURE__ */ new Map());
+	}
+	return result;
+}
+function mergeWithDeep(target, source, merge, stack) {
+	if (isPrimitive(target)) target = Object(target);
+	if (source == null || typeof source !== "object") return target;
+	if (stack.has(source)) return clone(stack.get(source));
+	stack.set(source, target);
+	if (Array.isArray(source)) {
+		source = source.slice();
+		for (let i = 0; i < source.length; i++) source[i] = source[i] ?? void 0;
+	}
+	const sourceKeys = [...Object.keys(source), ...getSymbols(source)];
+	for (let i = 0; i < sourceKeys.length; i++) {
+		const key = sourceKeys[i];
+		if (isUnsafeProperty(key)) continue;
+		let sourceValue = source[key];
+		let targetValue = target[key];
+		if (isArguments(sourceValue)) sourceValue = { ...sourceValue };
+		if (isArguments(targetValue)) targetValue = { ...targetValue };
+		if (isBuffer(sourceValue)) sourceValue = cloneDeep(sourceValue);
+		if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) {
+			const cloned = [];
+			const targetKeys = Reflect.ownKeys(targetValue);
+			for (let i = 0; i < targetKeys.length; i++) {
+				const targetKey = targetKeys[i];
+				cloned[targetKey] = targetValue[targetKey];
+			}
+			targetValue = cloned;
+		} else if (isArrayLikeObject(targetValue)) {
+			const cloned = [];
+			for (let i = 0; i < targetValue.length; i++) cloned[i] = targetValue[i];
+			targetValue = cloned;
+		} else targetValue = [];
+		const merged = merge(targetValue, sourceValue, key, target, source, stack);
+		if (merged !== void 0) target[key] = merged;
+		else if (Array.isArray(sourceValue)) target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
+		else if (isObjectLike(targetValue) && isObjectLike(sourceValue) && (isPlainObject(targetValue) || isPlainObject(sourceValue) || isTypedArray(targetValue) || isTypedArray(sourceValue))) target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
+		else if (targetValue == null && isPlainObject(sourceValue)) target[key] = mergeWithDeep({}, sourceValue, merge, stack);
+		else if (targetValue == null && isTypedArray(sourceValue)) target[key] = cloneDeep(sourceValue);
+		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
+	}
+	return target;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/object/merge.mjs
+/**
+* Merges the properties of one or more source objects into the target object.
+*
+* This function performs a deep merge, recursively merging nested objects and arrays.
+* If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+* If a property in the source object is `undefined`, it will not overwrite a defined property in the target object.
+*
+* The function can handle multiple source objects and will merge them all into the target object.
+*
+* @param object - The target object into which the source object properties will be merged. This object is modified in place.
+* @param sources - The source objects whose properties will be merged into the target object.
+* @returns The updated target object with properties from the source object(s) merged in.
+*
+* @example
+* const target = { a: 1, b: { x: 1, y: 2 } };
+* const source = { b: { y: 3, z: 4 }, c: 5 };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+*
+* @example
+* const target = { a: [1, 2], b: { x: 1 } };
+* const source = { a: [3], b: { y: 2 } };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: [3], b: { x: 1, y: 2 } }
+*
+* @example
+* const target = { a: null };
+* const source = { a: [1, 2, 3] };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: [1, 2, 3] }
+*/
+function merge(object, ...sources) {
+	return mergeWith(object, ...sources, noop);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-ZIGJFQKS.mjs
+var import_dist = require_dist();
+var ZERO_WIDTH_SPACE = "​";
+var d3CurveTypes = {
+	curveBasis: basis_default,
+	curveBasisClosed: basisClosed_default,
+	curveBasisOpen: basisOpen_default,
+	curveBumpX: bumpX,
+	curveBumpY: bumpY,
+	curveBundle: bundle_default,
+	curveCardinalClosed: cardinalClosed_default,
+	curveCardinalOpen: cardinalOpen_default,
+	curveCardinal: cardinal_default,
+	curveCatmullRomClosed: catmullRomClosed_default,
+	curveCatmullRomOpen: catmullRomOpen_default,
+	curveCatmullRom: catmullRom_default,
+	curveLinear: linear_default,
+	curveLinearClosed: linearClosed_default,
+	curveMonotoneX: monotoneX,
+	curveMonotoneY: monotoneY,
+	curveNatural: natural_default,
+	curveStep: step_default,
+	curveStepAfter: stepAfter,
+	curveStepBefore: stepBefore
+};
+var directiveWithoutOpen = /\s*(?:(\w+)(?=:):|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi;
+var detectInit = /* @__PURE__ */ __name(function(text, config) {
+	const inits = detectDirective(text, /(?:init\b)|(?:initialize\b)/);
+	let results = {};
+	if (Array.isArray(inits)) {
+		const args = inits.map((init) => init.args);
+		sanitizeDirective(args);
+		results = assignWithDepth_default(results, [...args]);
+	} else results = inits.args;
+	if (!results) return;
+	let type = detectType(text, config);
+	const prop = "config";
+	if (results[prop] !== void 0) {
+		if (type === "flowchart-v2") type = "flowchart";
+		results[type] = results[prop];
+		delete results[prop];
+	}
+	return results;
+}, "detectInit");
+var detectDirective = /* @__PURE__ */ __name(function(text, type = null) {
+	try {
+		const commentWithoutDirectives = new RegExp(`[%]{2}(?![{]${directiveWithoutOpen.source})(?=[}][%]{2}).*
+`, "ig");
+		text = text.trim().replace(commentWithoutDirectives, "").replace(/'/gm, "\"");
+		log.debug(`Detecting diagram directive${type !== null ? " type:" + type : ""} based on the text:${text}`);
+		let match;
+		const result = [];
+		while ((match = directiveRegex.exec(text)) !== null) {
+			if (match.index === directiveRegex.lastIndex) directiveRegex.lastIndex++;
+			if (match && !type || type && match[1]?.match(type) || type && match[2]?.match(type)) {
+				const type2 = match[1] ? match[1] : match[2];
+				const args = match[3] ? match[3].trim() : match[4] ? JSON.parse(match[4].trim()) : null;
+				result.push({
+					type: type2,
+					args
+				});
+			}
+		}
+		if (result.length === 0) return {
+			type: text,
+			args: null
+		};
+		return result.length === 1 ? result[0] : result;
+	} catch (error) {
+		log.error(`ERROR: ${error.message} - Unable to parse directive type: '${type}' based on the text: '${text}'`);
+		return {
+			type: void 0,
+			args: null
+		};
+	}
+}, "detectDirective");
+var removeDirectives = /* @__PURE__ */ __name(function(text) {
+	return text.replace(directiveRegex, "");
+}, "removeDirectives");
+var isSubstringInArray = /* @__PURE__ */ __name(function(str, arr) {
+	for (const [i, element] of arr.entries()) if (element.match(str)) return i;
+	return -1;
+}, "isSubstringInArray");
+function interpolateToCurve(interpolate, defaultCurve) {
+	if (!interpolate) return defaultCurve;
+	return d3CurveTypes[`curve${interpolate.charAt(0).toUpperCase() + interpolate.slice(1)}`] ?? defaultCurve;
+}
+__name(interpolateToCurve, "interpolateToCurve");
+function formatUrl(linkStr, config) {
+	const url = linkStr.trim();
+	if (!url) return;
+	if (config.securityLevel !== "loose") return (0, import_dist.sanitizeUrl)(url);
+	return url;
+}
+__name(formatUrl, "formatUrl");
+var runFunc = /* @__PURE__ */ __name((functionName, ...params) => {
+	const arrPaths = functionName.split(".");
+	const len = arrPaths.length - 1;
+	const fnName = arrPaths[len];
+	let obj = window;
+	for (let i = 0; i < len; i++) {
+		obj = obj[arrPaths[i]];
+		if (!obj) {
+			log.error(`Function name: ${functionName} not found in window`);
+			return;
+		}
+	}
+	obj[fnName](...params);
+}, "runFunc");
+function distance(p1, p2) {
+	if (!p1 || !p2) return 0;
+	return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+}
+__name(distance, "distance");
+function traverseEdge(points) {
+	let prevPoint;
+	let totalDistance = 0;
+	points.forEach((point) => {
+		totalDistance += distance(point, prevPoint);
+		prevPoint = point;
+	});
+	return calculatePoint(points, totalDistance / 2);
+}
+__name(traverseEdge, "traverseEdge");
+function calcLabelPosition(points) {
+	if (points.length === 1) return points[0];
+	return traverseEdge(points);
+}
+__name(calcLabelPosition, "calcLabelPosition");
+var roundNumber = /* @__PURE__ */ __name((num, precision = 2) => {
+	const factor = Math.pow(10, precision);
+	return Math.round(num * factor) / factor;
+}, "roundNumber");
+var calculatePoint = /* @__PURE__ */ __name((points, distanceToTraverse) => {
+	let prevPoint = void 0;
+	let remainingDistance = distanceToTraverse;
+	for (const point of points) {
+		if (prevPoint) {
+			const vectorDistance = distance(point, prevPoint);
+			if (vectorDistance === 0) return prevPoint;
+			if (vectorDistance < remainingDistance) remainingDistance -= vectorDistance;
+			else {
+				const distanceRatio = remainingDistance / vectorDistance;
+				if (distanceRatio <= 0) return prevPoint;
+				if (distanceRatio >= 1) return {
+					x: point.x,
+					y: point.y
+				};
+				if (distanceRatio > 0 && distanceRatio < 1) return {
+					x: roundNumber((1 - distanceRatio) * prevPoint.x + distanceRatio * point.x, 5),
+					y: roundNumber((1 - distanceRatio) * prevPoint.y + distanceRatio * point.y, 5)
+				};
+			}
+		}
+		prevPoint = point;
+	}
+	throw new Error("Could not find a suitable point for the given distance");
+}, "calculatePoint");
+var calcCardinalityPosition = /* @__PURE__ */ __name((isRelationTypePresent, points, initialPosition) => {
+	log.info(`our points ${JSON.stringify(points)}`);
+	if (points[0] !== initialPosition) points = points.reverse();
+	const center = calculatePoint(points, 25);
+	const d = isRelationTypePresent ? 10 : 5;
+	const angle = Math.atan2(points[0].y - center.y, points[0].x - center.x);
+	const cardinalityPosition = {
+		x: 0,
+		y: 0
+	};
+	cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2;
+	cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2;
+	return cardinalityPosition;
+}, "calcCardinalityPosition");
+function calcTerminalLabelPosition(terminalMarkerSize, position, _points) {
+	const points = structuredClone(_points);
+	log.info("our points", points);
+	if (position !== "start_left" && position !== "start_right") points.reverse();
+	const center = calculatePoint(points, 25 + terminalMarkerSize);
+	const d = 10 + terminalMarkerSize * .5;
+	const angle = Math.atan2(points[0].y - center.y, points[0].x - center.x);
+	const cardinalityPosition = {
+		x: 0,
+		y: 0
+	};
+	if (position === "start_left") {
+		cardinalityPosition.x = Math.sin(angle + Math.PI) * d + (points[0].x + center.x) / 2;
+		cardinalityPosition.y = -Math.cos(angle + Math.PI) * d + (points[0].y + center.y) / 2;
+	} else if (position === "end_right") {
+		cardinalityPosition.x = Math.sin(angle - Math.PI) * d + (points[0].x + center.x) / 2 - 5;
+		cardinalityPosition.y = -Math.cos(angle - Math.PI) * d + (points[0].y + center.y) / 2 - 5;
+	} else if (position === "end_left") {
+		cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2 - 5;
+		cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2 - 5;
+	} else {
+		cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2;
+		cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2;
+	}
+	return cardinalityPosition;
+}
+__name(calcTerminalLabelPosition, "calcTerminalLabelPosition");
+function getStylesFromArray(arr) {
+	let style = "";
+	let labelStyle = "";
+	for (const element of arr) if (element !== void 0) if (element.startsWith("color:") || element.startsWith("text-align:")) labelStyle = labelStyle + element + ";";
+	else style = style + element + ";";
+	return {
+		style,
+		labelStyle
+	};
+}
+__name(getStylesFromArray, "getStylesFromArray");
+var cnt = 0;
+var generateId = /* @__PURE__ */ __name(() => {
+	cnt++;
+	return "id-" + Math.random().toString(36).substr(2, 12) + "-" + cnt;
+}, "generateId");
+function makeRandomHex(length) {
+	let result = "";
+	const characters = "0123456789abcdef";
+	const charactersLength = 16;
+	for (let i = 0; i < length; i++) result += characters.charAt(Math.floor(Math.random() * charactersLength));
+	return result;
+}
+__name(makeRandomHex, "makeRandomHex");
+var random = /* @__PURE__ */ __name((options) => {
+	return makeRandomHex(options.length);
+}, "random");
+var getTextObj = /* @__PURE__ */ __name(function() {
+	return {
+		x: 0,
+		y: 0,
+		fill: void 0,
+		anchor: "start",
+		style: "#666",
+		width: 100,
+		height: 100,
+		textMargin: 0,
+		rx: 0,
+		ry: 0,
+		valign: void 0,
+		text: ""
+	};
+}, "getTextObj");
+var drawSimpleText = /* @__PURE__ */ __name(function(elem, textData) {
+	const nText = textData.text.replace(common_default.lineBreakRegex, " ");
+	const [, _fontSizePx] = parseFontSize(textData.fontSize);
+	const textElem = elem.append("text");
+	textElem.attr("x", textData.x);
+	textElem.attr("y", textData.y);
+	textElem.style("text-anchor", textData.anchor);
+	textElem.style("font-family", textData.fontFamily);
+	textElem.style("font-size", _fontSizePx);
+	textElem.style("font-weight", textData.fontWeight);
+	textElem.attr("fill", textData.fill);
+	if (textData.class !== void 0) textElem.attr("class", textData.class);
+	const span = textElem.append("tspan");
+	span.attr("x", textData.x + textData.textMargin * 2);
+	span.attr("fill", textData.fill);
+	span.text(nText);
+	return textElem;
+}, "drawSimpleText");
+var wrapLabel = memoize((label, maxWidth, config) => {
+	if (!label) return label;
+	config = Object.assign({
+		fontSize: 12,
+		fontWeight: 400,
+		fontFamily: "Arial",
+		joinWith: "<br/>"
+	}, config);
+	if (common_default.hasBreaks(label)) return label;
+	const words = label.split(" ").filter(Boolean);
+	const completedLines = [];
+	let nextLine = "";
+	words.forEach((word, index) => {
+		const wordLength = calculateTextWidth(`${word} `, config);
+		const nextLineLength = calculateTextWidth(nextLine, config);
+		if (wordLength > maxWidth) {
+			const { hyphenatedStrings, remainingWord } = breakString(word, maxWidth, "-", config);
+			completedLines.push(nextLine, ...hyphenatedStrings);
+			nextLine = remainingWord;
+		} else if (nextLineLength + wordLength >= maxWidth) {
+			completedLines.push(nextLine);
+			nextLine = word;
+		} else nextLine = [nextLine, word].filter(Boolean).join(" ");
+		if (index + 1 === words.length) completedLines.push(nextLine);
+	});
+	return completedLines.filter((line) => line !== "").join(config.joinWith);
+}, (label, maxWidth, config) => `${label}${maxWidth}${config.fontSize}${config.fontWeight}${config.fontFamily}${config.joinWith}`);
+var breakString = memoize((word, maxWidth, hyphenCharacter = "-", config) => {
+	config = Object.assign({
+		fontSize: 12,
+		fontWeight: 400,
+		fontFamily: "Arial",
+		margin: 0
+	}, config);
+	const characters = [...word];
+	const lines = [];
+	let currentLine = "";
+	characters.forEach((character, index) => {
+		const nextLine = `${currentLine}${character}`;
+		if (calculateTextWidth(nextLine, config) >= maxWidth) {
+			const currentCharacter = index + 1;
+			const isLastLine = characters.length === currentCharacter;
+			const hyphenatedNextLine = `${nextLine}${hyphenCharacter}`;
+			lines.push(isLastLine ? nextLine : hyphenatedNextLine);
+			currentLine = "";
+		} else currentLine = nextLine;
+	});
+	return {
+		hyphenatedStrings: lines,
+		remainingWord: currentLine
+	};
+}, (word, maxWidth, hyphenCharacter = "-", config) => `${word}${maxWidth}${hyphenCharacter}${config.fontSize}${config.fontWeight}${config.fontFamily}`);
+function calculateTextHeight(text, config) {
+	return calculateTextDimensions(text, config).height;
+}
+__name(calculateTextHeight, "calculateTextHeight");
+function calculateTextWidth(text, config) {
+	return calculateTextDimensions(text, config).width;
+}
+__name(calculateTextWidth, "calculateTextWidth");
+var calculateTextDimensions = memoize((text, config) => {
+	const { fontSize = 12, fontFamily = "Arial", fontWeight = 400 } = config;
+	if (!text) return {
+		width: 0,
+		height: 0
+	};
+	const [, _fontSizePx] = parseFontSize(fontSize);
+	const fontFamilies = ["sans-serif", fontFamily];
+	const lines = text.split(common_default.lineBreakRegex);
+	const dims = [];
+	const body = select_default("body");
+	if (!body.remove) return {
+		width: 0,
+		height: 0,
+		lineHeight: 0
+	};
+	const g = body.append("svg");
+	for (const fontFamily2 of fontFamilies) {
+		let cHeight = 0;
+		const dim = {
+			width: 0,
+			height: 0,
+			lineHeight: 0
+		};
+		for (const line of lines) {
+			const textObj = getTextObj();
+			textObj.text = line || "​";
+			const textElem = drawSimpleText(g, textObj).style("font-size", _fontSizePx).style("font-weight", fontWeight).style("font-family", fontFamily2);
+			const bBox = (textElem._groups || textElem)[0][0].getBBox();
+			if (bBox.width === 0 && bBox.height === 0) throw new Error("svg element not in render tree");
+			dim.width = Math.round(Math.max(dim.width, bBox.width));
+			cHeight = Math.round(bBox.height);
+			dim.height += cHeight;
+			dim.lineHeight = Math.round(Math.max(dim.lineHeight, cHeight));
+		}
+		dims.push(dim);
+	}
+	g.remove();
+	return dims[isNaN(dims[1].height) || isNaN(dims[1].width) || isNaN(dims[1].lineHeight) || dims[0].height > dims[1].height && dims[0].width > dims[1].width && dims[0].lineHeight > dims[1].lineHeight ? 0 : 1];
+}, (text, config) => `${text}${config.fontSize}${config.fontWeight}${config.fontFamily}`);
+var InitIDGenerator = class {
+	constructor(deterministic = false, seed) {
+		this.count = 0;
+		this.count = seed ? seed.length : 0;
+		this.next = deterministic ? () => this.count++ : () => Date.now();
+	}
+	static {
+		__name(this, "InitIDGenerator");
+	}
+};
+var decoder;
+var entityDecode = /* @__PURE__ */ __name(function(html) {
+	decoder = decoder || document.createElement("div");
+	html = escape(html).replace(/%26/g, "&").replace(/%23/g, "#").replace(/%3B/g, ";");
+	decoder.innerHTML = html;
+	return unescape(decoder.textContent);
+}, "entityDecode");
+function isDetailedError(error) {
+	return "str" in error;
+}
+__name(isDetailedError, "isDetailedError");
+var insertTitle = /* @__PURE__ */ __name((parent, cssClass, titleTopMargin, title) => {
+	if (!title) return;
+	const bounds = parent.node()?.getBBox();
+	if (!bounds) return;
+	parent.append("text").text(title).attr("text-anchor", "middle").attr("x", bounds.x + bounds.width / 2).attr("y", -titleTopMargin).attr("class", cssClass);
+}, "insertTitle");
+var parseFontSize = /* @__PURE__ */ __name((fontSize) => {
+	if (typeof fontSize === "number") return [fontSize, fontSize + "px"];
+	const fontSizeNumber = parseInt(fontSize ?? "", 10);
+	if (Number.isNaN(fontSizeNumber)) return [void 0, void 0];
+	else if (fontSize === String(fontSizeNumber)) return [fontSizeNumber, fontSize + "px"];
+	else return [fontSizeNumber, fontSize];
+}, "parseFontSize");
+function cleanAndMerge(defaultData, data) {
+	return merge({}, defaultData, data);
+}
+__name(cleanAndMerge, "cleanAndMerge");
+var utils_default = {
+	assignWithDepth: assignWithDepth_default,
+	wrapLabel,
+	calculateTextHeight,
+	calculateTextWidth,
+	calculateTextDimensions,
+	cleanAndMerge,
+	detectInit,
+	detectDirective,
+	isSubstringInArray,
+	interpolateToCurve,
+	calcLabelPosition,
+	calcCardinalityPosition,
+	calcTerminalLabelPosition,
+	formatUrl,
+	getStylesFromArray,
+	generateId,
+	random,
+	runFunc,
+	entityDecode,
+	insertTitle,
+	isLabelCoordinateInPath,
+	parseFontSize,
+	InitIDGenerator
+};
+var encodeEntities = /* @__PURE__ */ __name(function(text) {
+	let txt = text;
+	txt = txt.replace(/style.*:\S*#.*;/g, function(s) {
+		return s.substring(0, s.length - 1);
+	});
+	txt = txt.replace(/classDef.*:\S*#.*;/g, function(s) {
+		return s.substring(0, s.length - 1);
+	});
+	txt = txt.replace(/#\w+;/g, function(s) {
+		const innerTxt = s.substring(1, s.length - 1);
+		if (/^\+?\d+$/.test(innerTxt)) return "fl°°" + innerTxt + "¶ß";
+		else return "fl°" + innerTxt + "¶ß";
+	});
+	return txt;
+}, "encodeEntities");
+var decodeEntities = /* @__PURE__ */ __name(function(text) {
+	return text.replace(/fl°°/g, "&#").replace(/fl°/g, "&").replace(/¶ß/g, ";");
+}, "decodeEntities");
+var getEdgeId = /* @__PURE__ */ __name((from, to, { counter = 0, prefix, suffix }, id) => {
+	if (id) return id;
+	return `${prefix ? `${prefix}_` : ""}${from}_${to}_${counter}${suffix ? `_${suffix}` : ""}`;
+}, "getEdgeId");
+function handleUndefinedAttr(attrValue) {
+	return attrValue ?? null;
+}
+__name(handleUndefinedAttr, "handleUndefinedAttr");
+function isLabelCoordinateInPath(point, dAttr) {
+	const roundedX = Math.round(point.x);
+	const roundedY = Math.round(point.y);
+	const sanitizedD = dAttr.replace(/(\d+\.\d+)/g, (match) => Math.round(parseFloat(match)).toString());
+	return sanitizedD.includes(roundedX.toString()) || sanitizedD.includes(roundedY.toString());
+}
+__name(isLabelCoordinateInPath, "isLabelCoordinateInPath");
+
+//#endregion
+export { cardinal_default as $, float64ArrayTag as A, symbolTag as B, argumentsTag as C, dataViewTag as D, booleanTag as E, numberTag as F, getTag as G, uint32ArrayTag as H, objectTag as I, step_default as J, stepAfter as K, regexpTag as L, int32ArrayTag as M, int8ArrayTag as N, dateTag as O, mapTag as P, catmullRom_default as Q, setTag as R, isBuffer as S, arrayTag as T, uint8ArrayTag as U, uint16ArrayTag as V, uint8ClampedArrayTag as W, monotoneX as X, natural_default as Y, monotoneY as Z, wrapLabel as _, decodeEntities as a, isPrimitive as b, getEdgeId as c, interpolateToCurve as d, basis_default as et, isDetailedError as f, utils_default as g, removeDirectives as h, cleanAndMerge as i, int16ArrayTag as j, float32ArrayTag as k, getStylesFromArray as l, random as m, calculateTextHeight as n, bumpY as nt, encodeEntities as o, parseFontSize as p, stepBefore as q, calculateTextWidth as r, linear_default as rt, generateId as s, calculateTextDimensions as t, bumpX as tt, handleUndefinedAttr as u, isTypedArray as v, arrayBufferTag as w, isArrayLike as x, isArguments as y, stringTag as z };