@blueking/ai-blueking 2.0.0-dev.1 → 2.0.0-dev.3

package/dist/vue2/chunk-S3R3BYOJ-Bs_r55Kk.js

@@ -0,0 +1,1222 @@
+import { C as isFunction_default, D as _root_default, O as eq_default, T as _baseGetTag_default, _ as _Uint8Array_default, a as _overArg_default, c as isTypedArray_default, f as _isIndex_default, g as isArray_default, h as isObjectLike_default, i as isArrayLike_default, m as isArguments_default, n as identity_default, o as _isPrototype_default, p as isBuffer_default, r as memoize_default, s as _arrayLikeKeys_default, t as _baseFor_default, v as _Stack_default, w as isObject_default, x as _getNative_default } from "./_baseFor-DAbrc8SN.js";
+import { g as log, h as __name, p as select_default } from "./src-VlKYSsxJ.js";
+import { F as sanitizeDirective, f as detectType, m as directiveRegex, r as assignWithDepth_default, s as common_default } from "./chunk-ABZYJK2D-gsx40GnJ.js";
+import { o as epsilon } from "./math-DF_v6dOl.js";
+import { t as require_dist } from "./dist-xWJvauxf.js";
+function Linear(c) {
+	this._context = c;
+}
+Linear.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._point = 0;
+	},
+	lineEnd: function() {
+		(this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(c, L) {
+		switch (c = +c, L = +L, this._point) {
+			case 0:
+				this._point = 1, this._line ? this._context.lineTo(c, L) : this._context.moveTo(c, L);
+				break;
+			case 1: this._point = 2;
+			default:
+				this._context.lineTo(c, L);
+				break;
+		}
+	}
+};
+function linear_default(c) {
+	return new Linear(c);
+}
+var Bump = class {
+	constructor(c, L) {
+		this._context = c, this._x = L;
+	}
+	areaStart() {
+		this._line = 0;
+	}
+	areaEnd() {
+		this._line = NaN;
+	}
+	lineStart() {
+		this._point = 0;
+	}
+	lineEnd() {
+		(this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+	}
+	point(c, L) {
+		switch (c = +c, L = +L, this._point) {
+			case 0:
+				this._point = 1, this._line ? this._context.lineTo(c, L) : this._context.moveTo(c, L);
+				break;
+			case 1: this._point = 2;
+			default:
+				this._x ? this._context.bezierCurveTo(this._x0 = (this._x0 + c) / 2, this._y0, this._x0, L, c, L) : this._context.bezierCurveTo(this._x0, this._y0 = (this._y0 + L) / 2, c, this._y0, c, L);
+				break;
+		}
+		this._x0 = c, this._y0 = L;
+	}
+};
+function bumpX(c) {
+	return new Bump(c, !0);
+}
+function bumpY(c) {
+	return new Bump(c, !1);
+}
+function noop_default() {}
+function point$3(c, L, R) {
+	c._context.bezierCurveTo((2 * c._x0 + c._x1) / 3, (2 * c._y0 + c._y1) / 3, (c._x0 + 2 * c._x1) / 3, (c._y0 + 2 * c._y1) / 3, (c._x0 + 4 * c._x1 + L) / 6, (c._y0 + 4 * c._y1 + R) / 6);
+}
+function Basis(c) {
+	this._context = c;
+}
+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;
+		}
+		(this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(c, L) {
+		switch (c = +c, L = +L, this._point) {
+			case 0:
+				this._point = 1, this._line ? this._context.lineTo(c, L) : this._context.moveTo(c, L);
+				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, c, L);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = c, this._y0 = this._y1, this._y1 = L;
+	}
+};
+function basis_default(c) {
+	return new Basis(c);
+}
+function BasisClosed(c) {
+	this._context = c;
+}
+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(c, L) {
+		switch (c = +c, L = +L, this._point) {
+			case 0:
+				this._point = 1, this._x2 = c, this._y2 = L;
+				break;
+			case 1:
+				this._point = 2, this._x3 = c, this._y3 = L;
+				break;
+			case 2:
+				this._point = 3, this._x4 = c, this._y4 = L, this._context.moveTo((this._x0 + 4 * this._x1 + c) / 6, (this._y0 + 4 * this._y1 + L) / 6);
+				break;
+			default:
+				point$3(this, c, L);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = c, this._y0 = this._y1, this._y1 = L;
+	}
+};
+function basisClosed_default(c) {
+	return new BasisClosed(c);
+}
+function BasisOpen(c) {
+	this._context = c;
+}
+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() {
+		(this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(c, L) {
+		switch (c = +c, L = +L, this._point) {
+			case 0:
+				this._point = 1;
+				break;
+			case 1:
+				this._point = 2;
+				break;
+			case 2:
+				this._point = 3;
+				var R = (this._x0 + 4 * this._x1 + c) / 6, z = (this._y0 + 4 * this._y1 + L) / 6;
+				this._line ? this._context.lineTo(R, z) : this._context.moveTo(R, z);
+				break;
+			case 3: this._point = 4;
+			default:
+				point$3(this, c, L);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = c, this._y0 = this._y1, this._y1 = L;
+	}
+};
+function basisOpen_default(c) {
+	return new BasisOpen(c);
+}
+function Bundle(c, L) {
+	this._basis = new Basis(c), this._beta = L;
+}
+Bundle.prototype = {
+	lineStart: function() {
+		this._x = [], this._y = [], this._basis.lineStart();
+	},
+	lineEnd: function() {
+		var c = this._x, L = this._y, R = c.length - 1;
+		if (R > 0) for (var z = c[0], B = L[0], V = c[R] - z, H = L[R] - B, U = -1, W; ++U <= R;) W = U / R, this._basis.point(this._beta * c[U] + (1 - this._beta) * (z + W * V), this._beta * L[U] + (1 - this._beta) * (B + W * H));
+		this._x = this._y = null, this._basis.lineEnd();
+	},
+	point: function(c, L) {
+		this._x.push(+c), this._y.push(+L);
+	}
+};
+var bundle_default = (function c(L) {
+	function R(c) {
+		return L === 1 ? new Basis(c) : new Bundle(c, L);
+	}
+	return R.beta = function(L) {
+		return c(+L);
+	}, R;
+})(.85);
+function point$2(c, L, R) {
+	c._context.bezierCurveTo(c._x1 + c._k * (c._x2 - c._x0), c._y1 + c._k * (c._y2 - c._y0), c._x2 + c._k * (c._x1 - L), c._y2 + c._k * (c._y1 - R), c._x2, c._y2);
+}
+function Cardinal(c, L) {
+	this._context = c, this._k = (1 - L) / 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;
+		}
+		(this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(c, L) {
+		switch (c = +c, L = +L, this._point) {
+			case 0:
+				this._point = 1, this._line ? this._context.lineTo(c, L) : this._context.moveTo(c, L);
+				break;
+			case 1:
+				this._point = 2, this._x1 = c, this._y1 = L;
+				break;
+			case 2: this._point = 3;
+			default:
+				point$2(this, c, L);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = c, this._y0 = this._y1, this._y1 = this._y2, this._y2 = L;
+	}
+};
+var cardinal_default = (function c(L) {
+	function R(c) {
+		return new Cardinal(c, L);
+	}
+	return R.tension = function(L) {
+		return c(+L);
+	}, R;
+})(0);
+function CardinalClosed(c, L) {
+	this._context = c, this._k = (1 - L) / 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(c, L) {
+		switch (c = +c, L = +L, this._point) {
+			case 0:
+				this._point = 1, this._x3 = c, this._y3 = L;
+				break;
+			case 1:
+				this._point = 2, this._context.moveTo(this._x4 = c, this._y4 = L);
+				break;
+			case 2:
+				this._point = 3, this._x5 = c, this._y5 = L;
+				break;
+			default:
+				point$2(this, c, L);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = c, this._y0 = this._y1, this._y1 = this._y2, this._y2 = L;
+	}
+};
+var cardinalClosed_default = (function c(L) {
+	function R(c) {
+		return new CardinalClosed(c, L);
+	}
+	return R.tension = function(L) {
+		return c(+L);
+	}, R;
+})(0);
+function CardinalOpen(c, L) {
+	this._context = c, this._k = (1 - L) / 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() {
+		(this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(c, L) {
+		switch (c = +c, L = +L, 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, c, L);
+				break;
+		}
+		this._x0 = this._x1, this._x1 = this._x2, this._x2 = c, this._y0 = this._y1, this._y1 = this._y2, this._y2 = L;
+	}
+};
+var cardinalOpen_default = (function c(L) {
+	function R(c) {
+		return new CardinalOpen(c, L);
+	}
+	return R.tension = function(L) {
+		return c(+L);
+	}, R;
+})(0);
+function point$1(c, L, R) {
+	var z = c._x1, B = c._y1, V = c._x2, H = c._y2;
+	if (c._l01_a > 1e-12) {
+		var U = 2 * c._l01_2a + 3 * c._l01_a * c._l12_a + c._l12_2a, W = 3 * c._l01_a * (c._l01_a + c._l12_a);
+		z = (z * U - c._x0 * c._l12_2a + c._x2 * c._l01_2a) / W, B = (B * U - c._y0 * c._l12_2a + c._y2 * c._l01_2a) / W;
+	}
+	if (c._l23_a > 1e-12) {
+		var G = 2 * c._l23_2a + 3 * c._l23_a * c._l12_a + c._l12_2a, K = 3 * c._l23_a * (c._l23_a + c._l12_a);
+		V = (V * G + c._x1 * c._l23_2a - L * c._l12_2a) / K, H = (H * G + c._y1 * c._l23_2a - R * c._l12_2a) / K;
+	}
+	c._context.bezierCurveTo(z, B, V, H, c._x2, c._y2);
+}
+function CatmullRom(c, L) {
+	this._context = c, this._alpha = L;
+}
+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;
+		}
+		(this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(c, L) {
+		if (c = +c, L = +L, this._point) {
+			var R = this._x2 - c, z = this._y2 - L;
+			this._l23_a = Math.sqrt(this._l23_2a = (R * R + z * z) ** +this._alpha);
+		}
+		switch (this._point) {
+			case 0:
+				this._point = 1, this._line ? this._context.lineTo(c, L) : this._context.moveTo(c, L);
+				break;
+			case 1:
+				this._point = 2;
+				break;
+			case 2: this._point = 3;
+			default:
+				point$1(this, c, L);
+				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 = c, this._y0 = this._y1, this._y1 = this._y2, this._y2 = L;
+	}
+};
+var catmullRom_default = (function c(L) {
+	function R(c) {
+		return L ? new CatmullRom(c, L) : new Cardinal(c, 0);
+	}
+	return R.alpha = function(L) {
+		return c(+L);
+	}, R;
+})(.5);
+function CatmullRomClosed(c, L) {
+	this._context = c, this._alpha = L;
+}
+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(c, L) {
+		if (c = +c, L = +L, this._point) {
+			var R = this._x2 - c, z = this._y2 - L;
+			this._l23_a = Math.sqrt(this._l23_2a = (R * R + z * z) ** +this._alpha);
+		}
+		switch (this._point) {
+			case 0:
+				this._point = 1, this._x3 = c, this._y3 = L;
+				break;
+			case 1:
+				this._point = 2, this._context.moveTo(this._x4 = c, this._y4 = L);
+				break;
+			case 2:
+				this._point = 3, this._x5 = c, this._y5 = L;
+				break;
+			default:
+				point$1(this, c, L);
+				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 = c, this._y0 = this._y1, this._y1 = this._y2, this._y2 = L;
+	}
+};
+var catmullRomClosed_default = (function c(L) {
+	function R(c) {
+		return L ? new CatmullRomClosed(c, L) : new CardinalClosed(c, 0);
+	}
+	return R.alpha = function(L) {
+		return c(+L);
+	}, R;
+})(.5);
+function CatmullRomOpen(c, L) {
+	this._context = c, this._alpha = L;
+}
+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() {
+		(this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(c, L) {
+		if (c = +c, L = +L, this._point) {
+			var R = this._x2 - c, z = this._y2 - L;
+			this._l23_a = Math.sqrt(this._l23_2a = (R * R + z * z) ** +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, c, L);
+				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 = c, this._y0 = this._y1, this._y1 = this._y2, this._y2 = L;
+	}
+};
+var catmullRomOpen_default = (function c(L) {
+	function R(c) {
+		return L ? new CatmullRomOpen(c, L) : new CardinalOpen(c, 0);
+	}
+	return R.alpha = function(L) {
+		return c(+L);
+	}, R;
+})(.5);
+function LinearClosed(c) {
+	this._context = c;
+}
+LinearClosed.prototype = {
+	areaStart: noop_default,
+	areaEnd: noop_default,
+	lineStart: function() {
+		this._point = 0;
+	},
+	lineEnd: function() {
+		this._point && this._context.closePath();
+	},
+	point: function(c, L) {
+		c = +c, L = +L, this._point ? this._context.lineTo(c, L) : (this._point = 1, this._context.moveTo(c, L));
+	}
+};
+function linearClosed_default(c) {
+	return new LinearClosed(c);
+}
+function sign(c) {
+	return c < 0 ? -1 : 1;
+}
+function slope3(c, L, R) {
+	var z = c._x1 - c._x0, B = L - c._x1, V = (c._y1 - c._y0) / (z || B < 0 && -0), H = (R - c._y1) / (B || z < 0 && -0), U = (V * B + H * z) / (z + B);
+	return (sign(V) + sign(H)) * Math.min(Math.abs(V), Math.abs(H), .5 * Math.abs(U)) || 0;
+}
+function slope2(c, L) {
+	var R = c._x1 - c._x0;
+	return R ? (3 * (c._y1 - c._y0) / R - L) / 2 : L;
+}
+function point(c, L, R) {
+	var z = c._x0, B = c._y0, V = c._x1, H = c._y1, U = (V - z) / 3;
+	c._context.bezierCurveTo(z + U, B + U * L, V - U, H - U * R, V, H);
+}
+function MonotoneX(c) {
+	this._context = c;
+}
+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;
+		}
+		(this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(c, L) {
+		var R = NaN;
+		if (c = +c, L = +L, !(c === this._x1 && L === this._y1)) {
+			switch (this._point) {
+				case 0:
+					this._point = 1, this._line ? this._context.lineTo(c, L) : this._context.moveTo(c, L);
+					break;
+				case 1:
+					this._point = 2;
+					break;
+				case 2:
+					this._point = 3, point(this, slope2(this, R = slope3(this, c, L)), R);
+					break;
+				default:
+					point(this, this._t0, R = slope3(this, c, L));
+					break;
+			}
+			this._x0 = this._x1, this._x1 = c, this._y0 = this._y1, this._y1 = L, this._t0 = R;
+		}
+	}
+};
+function MonotoneY(c) {
+	this._context = new ReflectContext(c);
+}
+(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(c, L) {
+	MonotoneX.prototype.point.call(this, L, c);
+};
+function ReflectContext(c) {
+	this._context = c;
+}
+ReflectContext.prototype = {
+	moveTo: function(c, L) {
+		this._context.moveTo(L, c);
+	},
+	closePath: function() {
+		this._context.closePath();
+	},
+	lineTo: function(c, L) {
+		this._context.lineTo(L, c);
+	},
+	bezierCurveTo: function(c, L, R, z, B, V) {
+		this._context.bezierCurveTo(L, c, z, R, V, B);
+	}
+};
+function monotoneX(c) {
+	return new MonotoneX(c);
+}
+function monotoneY(c) {
+	return new MonotoneY(c);
+}
+function Natural(c) {
+	this._context = c;
+}
+Natural.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x = [], this._y = [];
+	},
+	lineEnd: function() {
+		var c = this._x, L = this._y, R = c.length;
+		if (R) if (this._line ? this._context.lineTo(c[0], L[0]) : this._context.moveTo(c[0], L[0]), R === 2) this._context.lineTo(c[1], L[1]);
+		else for (var z = controlPoints(c), B = controlPoints(L), V = 0, H = 1; H < R; ++V, ++H) this._context.bezierCurveTo(z[0][V], B[0][V], z[1][V], B[1][V], c[H], L[H]);
+		(this._line || this._line !== 0 && R === 1) && this._context.closePath(), this._line = 1 - this._line, this._x = this._y = null;
+	},
+	point: function(c, L) {
+		this._x.push(+c), this._y.push(+L);
+	}
+};
+function controlPoints(c) {
+	var L, R = c.length - 1, z, B = Array(R), V = Array(R), H = Array(R);
+	for (B[0] = 0, V[0] = 2, H[0] = c[0] + 2 * c[1], L = 1; L < R - 1; ++L) B[L] = 1, V[L] = 4, H[L] = 4 * c[L] + 2 * c[L + 1];
+	for (B[R - 1] = 2, V[R - 1] = 7, H[R - 1] = 8 * c[R - 1] + c[R], L = 1; L < R; ++L) z = B[L] / V[L - 1], V[L] -= z, H[L] -= z * H[L - 1];
+	for (B[R - 1] = H[R - 1] / V[R - 1], L = R - 2; L >= 0; --L) B[L] = (H[L] - B[L + 1]) / V[L];
+	for (V[R - 1] = (c[R] + B[R - 1]) / 2, L = 0; L < R - 1; ++L) V[L] = 2 * c[L + 1] - B[L + 1];
+	return [B, V];
+}
+function natural_default(c) {
+	return new Natural(c);
+}
+function Step(c, L) {
+	this._context = c, this._t = L;
+}
+Step.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x = this._y = NaN, this._point = 0;
+	},
+	lineEnd: function() {
+		0 < this._t && this._t < 1 && this._point === 2 && this._context.lineTo(this._x, this._y), (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line >= 0 && (this._t = 1 - this._t, this._line = 1 - this._line);
+	},
+	point: function(c, L) {
+		switch (c = +c, L = +L, this._point) {
+			case 0:
+				this._point = 1, this._line ? this._context.lineTo(c, L) : this._context.moveTo(c, L);
+				break;
+			case 1: this._point = 2;
+			default:
+				if (this._t <= 0) this._context.lineTo(this._x, L), this._context.lineTo(c, L);
+				else {
+					var R = this._x * (1 - this._t) + c * this._t;
+					this._context.lineTo(R, this._y), this._context.lineTo(R, L);
+				}
+				break;
+		}
+		this._x = c, this._y = L;
+	}
+};
+function step_default(c) {
+	return new Step(c, .5);
+}
+function stepBefore(c) {
+	return new Step(c, 0);
+}
+function stepAfter(c) {
+	return new Step(c, 1);
+}
+var _defineProperty_default = function() {
+	try {
+		var c = _getNative_default(Object, "defineProperty");
+		return c({}, "", {}), c;
+	} catch {}
+}();
+function baseAssignValue(c, L, R) {
+	L == "__proto__" && _defineProperty_default ? _defineProperty_default(c, L, {
+		configurable: !0,
+		enumerable: !0,
+		value: R,
+		writable: !0
+	}) : c[L] = R;
+}
+var _baseAssignValue_default = baseAssignValue;
+function assignMergeValue(c, L, z) {
+	(z !== void 0 && !eq_default(c[L], z) || z === void 0 && !(L in c)) && _baseAssignValue_default(c, L, z);
+}
+var _assignMergeValue_default = assignMergeValue, freeExports = typeof exports == "object" && exports && !exports.nodeType && exports, freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module, Buffer = freeModule && freeModule.exports === freeExports ? _root_default.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+function cloneBuffer(c, L) {
+	if (L) return c.slice();
+	var R = c.length, z = allocUnsafe ? allocUnsafe(R) : new c.constructor(R);
+	return c.copy(z), z;
+}
+var _cloneBuffer_default = cloneBuffer;
+function cloneArrayBuffer(c) {
+	var L = new c.constructor(c.byteLength);
+	return new _Uint8Array_default(L).set(new _Uint8Array_default(c)), L;
+}
+var _cloneArrayBuffer_default = cloneArrayBuffer;
+function cloneTypedArray(c, L) {
+	var R = L ? _cloneArrayBuffer_default(c.buffer) : c.buffer;
+	return new c.constructor(R, c.byteOffset, c.length);
+}
+var _cloneTypedArray_default = cloneTypedArray;
+function copyArray(c, L) {
+	var R = -1, z = c.length;
+	for (L ||= Array(z); ++R < z;) L[R] = c[R];
+	return L;
+}
+var _copyArray_default = copyArray, objectCreate = Object.create, _baseCreate_default = function() {
+	function c() {}
+	return function(L) {
+		if (!isObject_default(L)) return {};
+		if (objectCreate) return objectCreate(L);
+		c.prototype = L;
+		var R = new c();
+		return c.prototype = void 0, R;
+	};
+}(), _getPrototype_default = _overArg_default(Object.getPrototypeOf, Object);
+function initCloneObject(c) {
+	return typeof c.constructor == "function" && !_isPrototype_default(c) ? _baseCreate_default(_getPrototype_default(c)) : {};
+}
+var _initCloneObject_default = initCloneObject;
+function isArrayLikeObject(c) {
+	return isObjectLike_default(c) && isArrayLike_default(c);
+}
+var isArrayLikeObject_default = isArrayLikeObject, objectTag = "[object Object]", funcProto = Function.prototype, objectProto = Object.prototype, funcToString = funcProto.toString, hasOwnProperty$2 = objectProto.hasOwnProperty, objectCtorString = funcToString.call(Object);
+function isPlainObject(c) {
+	if (!isObjectLike_default(c) || _baseGetTag_default(c) != objectTag) return !1;
+	var L = _getPrototype_default(c);
+	if (L === null) return !0;
+	var R = hasOwnProperty$2.call(L, "constructor") && L.constructor;
+	return typeof R == "function" && R instanceof R && funcToString.call(R) == objectCtorString;
+}
+var isPlainObject_default = isPlainObject;
+function safeGet(c, L) {
+	if (!(L === "constructor" && typeof c[L] == "function") && L != "__proto__") return c[L];
+}
+var _safeGet_default = safeGet, hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+function assignValue(c, L, z) {
+	var B = c[L];
+	(!(hasOwnProperty$1.call(c, L) && eq_default(B, z)) || z === void 0 && !(L in c)) && _baseAssignValue_default(c, L, z);
+}
+var _assignValue_default = assignValue;
+function copyObject(c, L, R, z) {
+	var B = !R;
+	R ||= {};
+	for (var V = -1, H = L.length; ++V < H;) {
+		var U = L[V], W = z ? z(R[U], c[U], U, R, c) : void 0;
+		W === void 0 && (W = c[U]), B ? _baseAssignValue_default(R, U, W) : _assignValue_default(R, U, W);
+	}
+	return R;
+}
+var _copyObject_default = copyObject;
+function nativeKeysIn(c) {
+	var L = [];
+	if (c != null) for (var R in Object(c)) L.push(R);
+	return L;
+}
+var _nativeKeysIn_default = nativeKeysIn, hasOwnProperty = Object.prototype.hasOwnProperty;
+function baseKeysIn(c) {
+	if (!isObject_default(c)) return _nativeKeysIn_default(c);
+	var L = _isPrototype_default(c), R = [];
+	for (var z in c) z == "constructor" && (L || !hasOwnProperty.call(c, z)) || R.push(z);
+	return R;
+}
+var _baseKeysIn_default = baseKeysIn;
+function keysIn(c) {
+	return isArrayLike_default(c) ? _arrayLikeKeys_default(c, !0) : _baseKeysIn_default(c);
+}
+var keysIn_default = keysIn;
+function toPlainObject(c) {
+	return _copyObject_default(c, keysIn_default(c));
+}
+var toPlainObject_default = toPlainObject;
+function baseMergeDeep(L, R, z, B, V, U, G) {
+	var K = _safeGet_default(L, z), q = _safeGet_default(R, z), J = G.get(q);
+	if (J) {
+		_assignMergeValue_default(L, z, J);
+		return;
+	}
+	var Y = U ? U(K, q, z + "", L, R, G) : void 0, X = Y === void 0;
+	if (X) {
+		var Z = isArray_default(q), Q = !Z && isBuffer_default(q), $ = !Z && !Q && isTypedArray_default(q);
+		Y = q, Z || Q || $ ? isArray_default(K) ? Y = K : isArrayLikeObject_default(K) ? Y = _copyArray_default(K) : Q ? (X = !1, Y = _cloneBuffer_default(q, !0)) : $ ? (X = !1, Y = _cloneTypedArray_default(q, !0)) : Y = [] : isPlainObject_default(q) || isArguments_default(q) ? (Y = K, isArguments_default(K) ? Y = toPlainObject_default(K) : (!isObject_default(K) || isFunction_default(K)) && (Y = _initCloneObject_default(q))) : X = !1;
+	}
+	X && (G.set(q, Y), V(Y, q, B, U, G), G.delete(q)), _assignMergeValue_default(L, z, Y);
+}
+var _baseMergeDeep_default = baseMergeDeep;
+function baseMerge(c, L, R, z, B) {
+	c !== L && _baseFor_default(L, function(V, H) {
+		if (B ||= new _Stack_default(), isObject_default(V)) _baseMergeDeep_default(c, L, H, R, baseMerge, z, B);
+		else {
+			var U = z ? z(_safeGet_default(c, H), V, H + "", c, L, B) : void 0;
+			U === void 0 && (U = V), _assignMergeValue_default(c, H, U);
+		}
+	}, keysIn_default);
+}
+var _baseMerge_default = baseMerge;
+function apply(c, L, R) {
+	switch (R.length) {
+		case 0: return c.call(L);
+		case 1: return c.call(L, R[0]);
+		case 2: return c.call(L, R[0], R[1]);
+		case 3: return c.call(L, R[0], R[1], R[2]);
+	}
+	return c.apply(L, R);
+}
+var _apply_default = apply, nativeMax = Math.max;
+function overRest(c, L, R) {
+	return L = nativeMax(L === void 0 ? c.length - 1 : L, 0), function() {
+		for (var z = arguments, B = -1, V = nativeMax(z.length - L, 0), H = Array(V); ++B < V;) H[B] = z[L + B];
+		B = -1;
+		for (var U = Array(L + 1); ++B < L;) U[B] = z[B];
+		return U[L] = R(H), _apply_default(c, this, U);
+	};
+}
+var _overRest_default = overRest;
+function constant(c) {
+	return function() {
+		return c;
+	};
+}
+var constant_default = constant, _baseSetToString_default = _defineProperty_default ? function(c, L) {
+	return _defineProperty_default(c, "toString", {
+		configurable: !0,
+		enumerable: !1,
+		value: constant_default(L),
+		writable: !0
+	});
+} : identity_default, HOT_COUNT = 800, HOT_SPAN = 16, nativeNow = Date.now;
+function shortOut(c) {
+	var L = 0, R = 0;
+	return function() {
+		var z = nativeNow(), B = HOT_SPAN - (z - R);
+		if (R = z, B > 0) {
+			if (++L >= HOT_COUNT) return arguments[0];
+		} else L = 0;
+		return c.apply(void 0, arguments);
+	};
+}
+var _setToString_default = shortOut(_baseSetToString_default);
+function baseRest(c, L) {
+	return _setToString_default(_overRest_default(c, L, identity_default), c + "");
+}
+var _baseRest_default = baseRest;
+function isIterateeCall(c, L, z) {
+	if (!isObject_default(z)) return !1;
+	var B = typeof L;
+	return (B == "number" ? isArrayLike_default(z) && _isIndex_default(L, z.length) : B == "string" && L in z) ? eq_default(z[L], c) : !1;
+}
+var _isIterateeCall_default = isIterateeCall;
+function createAssigner(c) {
+	return _baseRest_default(function(L, R) {
+		var z = -1, B = R.length, V = B > 1 ? R[B - 1] : void 0, H = B > 2 ? R[2] : void 0;
+		for (V = c.length > 3 && typeof V == "function" ? (B--, V) : void 0, H && _isIterateeCall_default(R[0], R[1], H) && (V = B < 3 ? void 0 : V, B = 1), L = Object(L); ++z < B;) {
+			var U = R[z];
+			U && c(L, U, z, V);
+		}
+		return L;
+	});
+}
+var merge_default = createAssigner(function(c, L, R) {
+	_baseMerge_default(c, L, R);
+}), import_dist = require_dist(), ZERO_WIDTH_SPACE = "​", 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
+}, directiveWithoutOpen = /\s*(?:(\w+)(?=:):|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi, detectInit = /* @__PURE__ */ __name(function(c, L) {
+	let R = detectDirective(c, /(?:init\b)|(?:initialize\b)/), z = {};
+	if (Array.isArray(R)) {
+		let c = R.map((c) => c.args);
+		sanitizeDirective(c), z = assignWithDepth_default(z, [...c]);
+	} else z = R.args;
+	if (!z) return;
+	let B = detectType(c, L), V = "config";
+	return z[V] !== void 0 && (B === "flowchart-v2" && (B = "flowchart"), z[B] = z[V], delete z[V]), z;
+}, "detectInit"), detectDirective = /* @__PURE__ */ __name(function(c, L = null) {
+	try {
+		let R = RegExp(`[%]{2}(?![{]${directiveWithoutOpen.source})(?=[}][%]{2}).*
+`, "ig");
+		c = c.trim().replace(R, "").replace(/'/gm, "\""), log.debug(`Detecting diagram directive${L === null ? "" : " type:" + L} based on the text:${c}`);
+		let z, B = [];
+		for (; (z = directiveRegex.exec(c)) !== null;) if (z.index === directiveRegex.lastIndex && directiveRegex.lastIndex++, z && !L || L && z[1]?.match(L) || L && z[2]?.match(L)) {
+			let c = z[1] ? z[1] : z[2], L = z[3] ? z[3].trim() : z[4] ? JSON.parse(z[4].trim()) : null;
+			B.push({
+				type: c,
+				args: L
+			});
+		}
+		return B.length === 0 ? {
+			type: c,
+			args: null
+		} : B.length === 1 ? B[0] : B;
+	} catch (R) {
+		return log.error(`ERROR: ${R.message} - Unable to parse directive type: '${L}' based on the text: '${c}'`), {
+			type: void 0,
+			args: null
+		};
+	}
+}, "detectDirective"), removeDirectives = /* @__PURE__ */ __name(function(c) {
+	return c.replace(directiveRegex, "");
+}, "removeDirectives"), isSubstringInArray = /* @__PURE__ */ __name(function(c, L) {
+	for (let [R, z] of L.entries()) if (z.match(c)) return R;
+	return -1;
+}, "isSubstringInArray");
+function interpolateToCurve(c, L) {
+	return c ? d3CurveTypes[`curve${c.charAt(0).toUpperCase() + c.slice(1)}`] ?? L : L;
+}
+__name(interpolateToCurve, "interpolateToCurve");
+function formatUrl(c, L) {
+	let R = c.trim();
+	if (R) return L.securityLevel === "loose" ? R : (0, import_dist.sanitizeUrl)(R);
+}
+__name(formatUrl, "formatUrl");
+var runFunc = /* @__PURE__ */ __name((c, ...L) => {
+	let R = c.split("."), z = R.length - 1, B = R[z], V = window;
+	for (let L = 0; L < z; L++) if (V = V[R[L]], !V) {
+		log.error(`Function name: ${c} not found in window`);
+		return;
+	}
+	V[B](...L);
+}, "runFunc");
+function distance(c, L) {
+	return !c || !L ? 0 : Math.sqrt((L.x - c.x) ** 2 + (L.y - c.y) ** 2);
+}
+__name(distance, "distance");
+function traverseEdge(c) {
+	let L, R = 0;
+	return c.forEach((c) => {
+		R += distance(c, L), L = c;
+	}), calculatePoint(c, R / 2);
+}
+__name(traverseEdge, "traverseEdge");
+function calcLabelPosition(c) {
+	return c.length === 1 ? c[0] : traverseEdge(c);
+}
+__name(calcLabelPosition, "calcLabelPosition");
+var roundNumber = /* @__PURE__ */ __name((c, L = 2) => {
+	let R = 10 ** L;
+	return Math.round(c * R) / R;
+}, "roundNumber"), calculatePoint = /* @__PURE__ */ __name((c, L) => {
+	let R, z = L;
+	for (let L of c) {
+		if (R) {
+			let c = distance(L, R);
+			if (c === 0) return R;
+			if (c < z) z -= c;
+			else {
+				let B = z / c;
+				if (B <= 0) return R;
+				if (B >= 1) return {
+					x: L.x,
+					y: L.y
+				};
+				if (B > 0 && B < 1) return {
+					x: roundNumber((1 - B) * R.x + B * L.x, 5),
+					y: roundNumber((1 - B) * R.y + B * L.y, 5)
+				};
+			}
+		}
+		R = L;
+	}
+	throw Error("Could not find a suitable point for the given distance");
+}, "calculatePoint"), calcCardinalityPosition = /* @__PURE__ */ __name((c, L, R) => {
+	log.info(`our points ${JSON.stringify(L)}`), L[0] !== R && (L = L.reverse());
+	let z = calculatePoint(L, 25), B = c ? 10 : 5, V = Math.atan2(L[0].y - z.y, L[0].x - z.x), H = {
+		x: 0,
+		y: 0
+	};
+	return H.x = Math.sin(V) * B + (L[0].x + z.x) / 2, H.y = -Math.cos(V) * B + (L[0].y + z.y) / 2, H;
+}, "calcCardinalityPosition");
+function calcTerminalLabelPosition(c, L, R) {
+	let z = structuredClone(R);
+	log.info("our points", z), L !== "start_left" && L !== "start_right" && z.reverse();
+	let B = calculatePoint(z, 25 + c), V = 10 + c * .5, H = Math.atan2(z[0].y - B.y, z[0].x - B.x), U = {
+		x: 0,
+		y: 0
+	};
+	return L === "start_left" ? (U.x = Math.sin(H + Math.PI) * V + (z[0].x + B.x) / 2, U.y = -Math.cos(H + Math.PI) * V + (z[0].y + B.y) / 2) : L === "end_right" ? (U.x = Math.sin(H - Math.PI) * V + (z[0].x + B.x) / 2 - 5, U.y = -Math.cos(H - Math.PI) * V + (z[0].y + B.y) / 2 - 5) : L === "end_left" ? (U.x = Math.sin(H) * V + (z[0].x + B.x) / 2 - 5, U.y = -Math.cos(H) * V + (z[0].y + B.y) / 2 - 5) : (U.x = Math.sin(H) * V + (z[0].x + B.x) / 2, U.y = -Math.cos(H) * V + (z[0].y + B.y) / 2), U;
+}
+__name(calcTerminalLabelPosition, "calcTerminalLabelPosition");
+function getStylesFromArray(c) {
+	let L = "", R = "";
+	for (let z of c) z !== void 0 && (z.startsWith("color:") || z.startsWith("text-align:") ? R = R + z + ";" : L = L + z + ";");
+	return {
+		style: L,
+		labelStyle: R
+	};
+}
+__name(getStylesFromArray, "getStylesFromArray");
+var cnt = 0, generateId = /* @__PURE__ */ __name(() => (cnt++, "id-" + Math.random().toString(36).substr(2, 12) + "-" + cnt), "generateId");
+function makeRandomHex(c) {
+	let L = "";
+	for (let R = 0; R < c; R++) L += "0123456789abcdef".charAt(Math.floor(Math.random() * 16));
+	return L;
+}
+__name(makeRandomHex, "makeRandomHex");
+var random = /* @__PURE__ */ __name((c) => makeRandomHex(c.length), "random"), 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"), drawSimpleText = /* @__PURE__ */ __name(function(c, L) {
+	let R = L.text.replace(common_default.lineBreakRegex, " "), [, z] = parseFontSize(L.fontSize), B = c.append("text");
+	B.attr("x", L.x), B.attr("y", L.y), B.style("text-anchor", L.anchor), B.style("font-family", L.fontFamily), B.style("font-size", z), B.style("font-weight", L.fontWeight), B.attr("fill", L.fill), L.class !== void 0 && B.attr("class", L.class);
+	let V = B.append("tspan");
+	return V.attr("x", L.x + L.textMargin * 2), V.attr("fill", L.fill), V.text(R), B;
+}, "drawSimpleText"), wrapLabel = memoize_default((c, L, R) => {
+	if (!c || (R = Object.assign({
+		fontSize: 12,
+		fontWeight: 400,
+		fontFamily: "Arial",
+		joinWith: "<br/>"
+	}, R), common_default.lineBreakRegex.test(c))) return c;
+	let z = c.split(" ").filter(Boolean), B = [], V = "";
+	return z.forEach((c, H) => {
+		let U = calculateTextWidth(`${c} `, R), W = calculateTextWidth(V, R);
+		if (U > L) {
+			let { hyphenatedStrings: z, remainingWord: H } = breakString(c, L, "-", R);
+			B.push(V, ...z), V = H;
+		} else W + U >= L ? (B.push(V), V = c) : V = [V, c].filter(Boolean).join(" ");
+		H + 1 === z.length && B.push(V);
+	}), B.filter((c) => c !== "").join(R.joinWith);
+}, (c, L, R) => `${c}${L}${R.fontSize}${R.fontWeight}${R.fontFamily}${R.joinWith}`), breakString = memoize_default((c, L, R = "-", z) => {
+	z = Object.assign({
+		fontSize: 12,
+		fontWeight: 400,
+		fontFamily: "Arial",
+		margin: 0
+	}, z);
+	let B = [...c], V = [], H = "";
+	return B.forEach((c, U) => {
+		let W = `${H}${c}`;
+		if (calculateTextWidth(W, z) >= L) {
+			let c = U + 1, L = B.length === c, z = `${W}${R}`;
+			V.push(L ? W : z), H = "";
+		} else H = W;
+	}), {
+		hyphenatedStrings: V,
+		remainingWord: H
+	};
+}, (c, L, R = "-", z) => `${c}${L}${R}${z.fontSize}${z.fontWeight}${z.fontFamily}`);
+function calculateTextHeight(c, L) {
+	return calculateTextDimensions(c, L).height;
+}
+__name(calculateTextHeight, "calculateTextHeight");
+function calculateTextWidth(c, L) {
+	return calculateTextDimensions(c, L).width;
+}
+__name(calculateTextWidth, "calculateTextWidth");
+var calculateTextDimensions = memoize_default((c, L) => {
+	let { fontSize: R = 12, fontFamily: z = "Arial", fontWeight: B = 400 } = L;
+	if (!c) return {
+		width: 0,
+		height: 0
+	};
+	let [, V] = parseFontSize(R), H = ["sans-serif", z], U = c.split(common_default.lineBreakRegex), W = [], G = select_default("body");
+	if (!G.remove) return {
+		width: 0,
+		height: 0,
+		lineHeight: 0
+	};
+	let K = G.append("svg");
+	for (let c of H) {
+		let L = 0, R = {
+			width: 0,
+			height: 0,
+			lineHeight: 0
+		};
+		for (let z of U) {
+			let H = getTextObj();
+			H.text = z || "​";
+			let U = drawSimpleText(K, H).style("font-size", V).style("font-weight", B).style("font-family", c), W = (U._groups || U)[0][0].getBBox();
+			if (W.width === 0 && W.height === 0) throw Error("svg element not in render tree");
+			R.width = Math.round(Math.max(R.width, W.width)), L = Math.round(W.height), R.height += L, R.lineHeight = Math.round(Math.max(R.lineHeight, L));
+		}
+		W.push(R);
+	}
+	return K.remove(), W[isNaN(W[1].height) || isNaN(W[1].width) || isNaN(W[1].lineHeight) || W[0].height > W[1].height && W[0].width > W[1].width && W[0].lineHeight > W[1].lineHeight ? 0 : 1];
+}, (c, L) => `${c}${L.fontSize}${L.fontWeight}${L.fontFamily}`), InitIDGenerator = class {
+	constructor(c = !1, L) {
+		this.count = 0, this.count = L ? L.length : 0, this.next = c ? () => this.count++ : () => Date.now();
+	}
+	static #e = __name(this, "InitIDGenerator");
+}, decoder, entityDecode = /* @__PURE__ */ __name(function(c) {
+	return decoder ||= document.createElement("div"), c = escape(c).replace(/%26/g, "&").replace(/%23/g, "#").replace(/%3B/g, ";"), decoder.innerHTML = c, unescape(decoder.textContent);
+}, "entityDecode");
+function isDetailedError(c) {
+	return "str" in c;
+}
+__name(isDetailedError, "isDetailedError");
+var insertTitle = /* @__PURE__ */ __name((c, L, R, z) => {
+	if (!z) return;
+	let B = c.node()?.getBBox();
+	B && c.append("text").text(z).attr("text-anchor", "middle").attr("x", B.x + B.width / 2).attr("y", -R).attr("class", L);
+}, "insertTitle"), parseFontSize = /* @__PURE__ */ __name((c) => {
+	if (typeof c == "number") return [c, c + "px"];
+	let L = parseInt(c ?? "", 10);
+	return Number.isNaN(L) ? [void 0, void 0] : c === String(L) ? [L, c + "px"] : [L, c];
+}, "parseFontSize");
+function cleanAndMerge(c, L) {
+	return merge_default({}, c, L);
+}
+__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
+}, encodeEntities = /* @__PURE__ */ __name(function(c) {
+	let L = c;
+	return L = L.replace(/style.*:\S*#.*;/g, function(c) {
+		return c.substring(0, c.length - 1);
+	}), L = L.replace(/classDef.*:\S*#.*;/g, function(c) {
+		return c.substring(0, c.length - 1);
+	}), L = L.replace(/#\w+;/g, function(c) {
+		let L = c.substring(1, c.length - 1);
+		return /^\+?\d+$/.test(L) ? "fl°°" + L + "¶ß" : "fl°" + L + "¶ß";
+	}), L;
+}, "encodeEntities"), decodeEntities = /* @__PURE__ */ __name(function(c) {
+	return c.replace(/fl°°/g, "&#").replace(/fl°/g, "&").replace(/¶ß/g, ";");
+}, "decodeEntities"), getEdgeId = /* @__PURE__ */ __name((c, L, { counter: R = 0, prefix: z, suffix: B }, V) => V || `${z ? `${z}_` : ""}${c}_${L}_${R}${B ? `_${B}` : ""}`, "getEdgeId");
+function handleUndefinedAttr(c) {
+	return c ?? null;
+}
+__name(handleUndefinedAttr, "handleUndefinedAttr");
+function isLabelCoordinateInPath(c, L) {
+	let R = Math.round(c.x), z = Math.round(c.y), B = L.replace(/(\d+\.\d+)/g, (c) => Math.round(parseFloat(c)).toString());
+	return B.includes(R.toString()) || B.includes(z.toString());
+}
+__name(isLabelCoordinateInPath, "isLabelCoordinateInPath");
+export { _copyArray_default as A, monotoneY as B, _overRest_default as C, isArrayLikeObject_default as D, _assignValue_default as E, stepAfter as F, bumpY as G, cardinal_default as H, stepBefore as I, linear_default as K, step_default as L, _cloneArrayBuffer_default as M, _cloneBuffer_default as N, _initCloneObject_default as O, _baseAssignValue_default as P, natural_default as R, constant_default as S, _copyObject_default as T, basis_default as U, catmullRom_default as V, bumpX as W, wrapLabel as _, decodeEntities as a, _baseRest_default as b, getEdgeId as c, interpolateToCurve as d, isDetailedError as f, utils_default as g, removeDirectives as h, cleanAndMerge as i, _cloneTypedArray_default as j, _getPrototype_default as k, getStylesFromArray as l, random as m, calculateTextHeight as n, encodeEntities as o, parseFontSize as p, calculateTextWidth as r, generateId as s, ZERO_WIDTH_SPACE as t, handleUndefinedAttr as u, merge_default as v, keysIn_default as w, _setToString_default as x, _isIterateeCall_default as y, monotoneX as z };