likec4 1.59.4 → 1.61.0

package/__app__/src/chunks/libs/bezier-js.mjs

@@ -1,1007 +0,0 @@
-import "../rolldown-runtime.mjs";
-//#region ../../node_modules/.pnpm/bezier-js@6.1.4/node_modules/bezier-js/src/utils.js
-var { abs: e, cos: n, sin: r, acos: i, atan2: a, sqrt: o, pow: s } = Math;
-function crt(e) {
-	return e < 0 ? -s(-e, 1 / 3) : s(e, 1 / 3);
-}
-var c = Math.PI, l = 2 * c, u = c / 2, f = 1e-6, p = 2 ** 53 - 1 || 9007199254740991, m = -(2 ** 53 - 1) || -9007199254740991, h = {
-	x: 0,
-	y: 0,
-	z: 0
-}, g = {
-	Tvalues: [
-		-.06405689286260563,
-		.06405689286260563,
-		-.1911188674736163,
-		.1911188674736163,
-		-.3150426796961634,
-		.3150426796961634,
-		-.4337935076260451,
-		.4337935076260451,
-		-.5454214713888396,
-		.5454214713888396,
-		-.6480936519369755,
-		.6480936519369755,
-		-.7401241915785544,
-		.7401241915785544,
-		-.820001985973903,
-		.820001985973903,
-		-.8864155270044011,
-		.8864155270044011,
-		-.9382745520027328,
-		.9382745520027328,
-		-.9747285559713095,
-		.9747285559713095,
-		-.9951872199970213,
-		.9951872199970213
-	],
-	Cvalues: [
-		.12793819534675216,
-		.12793819534675216,
-		.1258374563468283,
-		.1258374563468283,
-		.12167047292780339,
-		.12167047292780339,
-		.1155056680537256,
-		.1155056680537256,
-		.10744427011596563,
-		.10744427011596563,
-		.09761865210411388,
-		.09761865210411388,
-		.08619016153195327,
-		.08619016153195327,
-		.0733464814110803,
-		.0733464814110803,
-		.05929858491543678,
-		.05929858491543678,
-		.04427743881741981,
-		.04427743881741981,
-		.028531388628933663,
-		.028531388628933663,
-		.0123412297999872,
-		.0123412297999872
-	],
-	arcfn: function(e, n) {
-		let r = n(e), i = r.x * r.x + r.y * r.y;
-		return r.z !== void 0 && (i += r.z * r.z), o(i);
-	},
-	compute: function(e, n, r) {
-		if (e === 0) return n[0].t = 0, n[0];
-		let i = n.length - 1;
-		if (e === 1) return n[i].t = 1, n[i];
-		let a = 1 - e, o = n;
-		if (i === 0) return n[0].t = e, n[0];
-		if (i === 1) {
-			let n = {
-				x: a * o[0].x + e * o[1].x,
-				y: a * o[0].y + e * o[1].y,
-				t: e
-			};
-			return r && (n.z = a * o[0].z + e * o[1].z), n;
-		}
-		if (i < 4) {
-			let n = a * a, s = e * e, c, l, u, f = 0;
-			i === 2 ? (o = [
-				o[0],
-				o[1],
-				o[2],
-				h
-			], c = n, l = a * e * 2, u = s) : i === 3 && (c = n * a, l = n * e * 3, u = a * s * 3, f = e * s);
-			let p = {
-				x: c * o[0].x + l * o[1].x + u * o[2].x + f * o[3].x,
-				y: c * o[0].y + l * o[1].y + u * o[2].y + f * o[3].y,
-				t: e
-			};
-			return r && (p.z = c * o[0].z + l * o[1].z + u * o[2].z + f * o[3].z), p;
-		}
-		let s = JSON.parse(JSON.stringify(n));
-		for (; s.length > 1;) {
-			for (let n = 0; n < s.length - 1; n++) s[n] = {
-				x: s[n].x + (s[n + 1].x - s[n].x) * e,
-				y: s[n].y + (s[n + 1].y - s[n].y) * e
-			}, s[n].z !== void 0 && (s[n].z = s[n].z + (s[n + 1].z - s[n].z) * e);
-			s.splice(s.length - 1, 1);
-		}
-		return s[0].t = e, s[0];
-	},
-	computeWithRatios: function(e, n, r, i) {
-		let a = 1 - e, o = r, s = n, c = o[0], l = o[1], u = o[2], f = o[3], p;
-		if (c *= a, l *= e, s.length === 2) return p = c + l, {
-			x: (c * s[0].x + l * s[1].x) / p,
-			y: (c * s[0].y + l * s[1].y) / p,
-			z: i ? (c * s[0].z + l * s[1].z) / p : !1,
-			t: e
-		};
-		if (c *= a, l *= 2 * a, u *= e * e, s.length === 3) return p = c + l + u, {
-			x: (c * s[0].x + l * s[1].x + u * s[2].x) / p,
-			y: (c * s[0].y + l * s[1].y + u * s[2].y) / p,
-			z: i ? (c * s[0].z + l * s[1].z + u * s[2].z) / p : !1,
-			t: e
-		};
-		if (c *= a, l *= 1.5 * a, u *= 3 * a, f *= e * e * e, s.length === 4) return p = c + l + u + f, {
-			x: (c * s[0].x + l * s[1].x + u * s[2].x + f * s[3].x) / p,
-			y: (c * s[0].y + l * s[1].y + u * s[2].y + f * s[3].y) / p,
-			z: i ? (c * s[0].z + l * s[1].z + u * s[2].z + f * s[3].z) / p : !1,
-			t: e
-		};
-	},
-	derive: function(e, n) {
-		let r = [];
-		for (let i = e, a = i.length, o = a - 1; a > 1; a--, o--) {
-			let e = [];
-			for (let r = 0, a; r < o; r++) a = {
-				x: o * (i[r + 1].x - i[r].x),
-				y: o * (i[r + 1].y - i[r].y)
-			}, n && (a.z = o * (i[r + 1].z - i[r].z)), e.push(a);
-			r.push(e), i = e;
-		}
-		return r;
-	},
-	between: function(e, n, r) {
-		return n <= e && e <= r || g.approximately(e, n) || g.approximately(e, r);
-	},
-	approximately: function(n, r, i) {
-		return e(n - r) <= (i || f);
-	},
-	length: function(e) {
-		let n = .5, r = g.Tvalues.length, i = 0;
-		for (let a = 0, o; a < r; a++) o = n * g.Tvalues[a] + n, i += g.Cvalues[a] * g.arcfn(o, e);
-		return n * i;
-	},
-	map: function(e, n, r, i, a) {
-		let o = r - n;
-		return i + (a - i) * ((e - n) / o);
-	},
-	lerp: function(e, n, r) {
-		let i = {
-			x: n.x + e * (r.x - n.x),
-			y: n.y + e * (r.y - n.y)
-		};
-		return n.z !== void 0 && r.z !== void 0 && (i.z = n.z + e * (r.z - n.z)), i;
-	},
-	pointToString: function(e) {
-		let n = e.x + "/" + e.y;
-		return e.z !== void 0 && (n += "/" + e.z), n;
-	},
-	pointsToString: function(e) {
-		return "[" + e.map(g.pointToString).join(", ") + "]";
-	},
-	copy: function(e) {
-		return JSON.parse(JSON.stringify(e));
-	},
-	angle: function(e, n, r) {
-		let i = n.x - e.x, o = n.y - e.y, s = r.x - e.x, c = r.y - e.y;
-		return a(i * c - o * s, i * s + o * c);
-	},
-	round: function(e, n) {
-		let r = "" + e, i = r.indexOf(".");
-		return parseFloat(r.substring(0, i + 1 + n));
-	},
-	dist: function(e, n) {
-		let r = e.x - n.x, i = e.y - n.y;
-		return o(r * r + i * i);
-	},
-	closest: function(e, n) {
-		let r = s(2, 63), i, a;
-		return e.forEach(function(e, o) {
-			a = g.dist(n, e), a < r && (r = a, i = o);
-		}), {
-			mdist: r,
-			mpos: i
-		};
-	},
-	abcratio: function(n, r) {
-		if (r !== 2 && r !== 3) return !1;
-		if (n === void 0) n = .5;
-		else if (n === 0 || n === 1) return n;
-		let i = s(n, r) + s(1 - n, r);
-		return e((i - 1) / i);
-	},
-	projectionratio: function(e, n) {
-		if (n !== 2 && n !== 3) return !1;
-		if (e === void 0) e = .5;
-		else if (e === 0 || e === 1) return e;
-		let r = s(1 - e, n);
-		return r / (s(e, n) + r);
-	},
-	lli8: function(e, n, r, i, a, o, s, c) {
-		let l = (e * i - n * r) * (a - s) - (e - r) * (a * c - o * s), u = (e * i - n * r) * (o - c) - (n - i) * (a * c - o * s), f = (e - r) * (o - c) - (n - i) * (a - s);
-		return f != 0 && {
-			x: l / f,
-			y: u / f
-		};
-	},
-	lli4: function(e, n, r, i) {
-		let a = e.x, o = e.y, s = n.x, c = n.y, l = r.x, u = r.y, f = i.x, p = i.y;
-		return g.lli8(a, o, s, c, l, u, f, p);
-	},
-	lli: function(e, n) {
-		return g.lli4(e, e.c, n, n.c);
-	},
-	makeline: function(e, n) {
-		return new E(e.x, e.y, (e.x + n.x) / 2, (e.y + n.y) / 2, n.x, n.y);
-	},
-	findbbox: function(e) {
-		let n = p, r = p, i = m, a = m;
-		return e.forEach(function(e) {
-			let o = e.bbox();
-			n > o.x.min && (n = o.x.min), r > o.y.min && (r = o.y.min), i < o.x.max && (i = o.x.max), a < o.y.max && (a = o.y.max);
-		}), {
-			x: {
-				min: n,
-				mid: (n + i) / 2,
-				max: i,
-				size: i - n
-			},
-			y: {
-				min: r,
-				mid: (r + a) / 2,
-				max: a,
-				size: a - r
-			}
-		};
-	},
-	shapeintersections: function(e, n, r, i, a) {
-		if (!g.bboxoverlap(n, i)) return [];
-		let o = [], s = [
-			e.startcap,
-			e.forward,
-			e.back,
-			e.endcap
-		], c = [
-			r.startcap,
-			r.forward,
-			r.back,
-			r.endcap
-		];
-		return s.forEach(function(n) {
-			n.virtual || c.forEach(function(i) {
-				if (i.virtual) return;
-				let s = n.intersects(i, a);
-				s.length > 0 && (s.c1 = n, s.c2 = i, s.s1 = e, s.s2 = r, o.push(s));
-			});
-		}), o;
-	},
-	makeshape: function(e, n, r) {
-		let i = n.points.length, a = e.points.length, o = g.makeline(n.points[i - 1], e.points[0]), s = g.makeline(e.points[a - 1], n.points[0]), c = {
-			startcap: o,
-			forward: e,
-			back: n,
-			endcap: s,
-			bbox: g.findbbox([
-				o,
-				e,
-				n,
-				s
-			])
-		};
-		return c.intersections = function(e) {
-			return g.shapeintersections(c, c.bbox, e, e.bbox, r);
-		}, c;
-	},
-	getminmax: function(e, n, r) {
-		if (!r) return {
-			min: 0,
-			max: 0
-		};
-		let i = p, a = m, o, s;
-		r.indexOf(0) === -1 && (r = [0].concat(r)), r.indexOf(1) === -1 && r.push(1);
-		for (let c = 0, l = r.length; c < l; c++) o = r[c], s = e.get(o), s[n] < i && (i = s[n]), s[n] > a && (a = s[n]);
-		return {
-			min: i,
-			mid: (i + a) / 2,
-			max: a,
-			size: a - i
-		};
-	},
-	align: function(e, i) {
-		let o = i.p1.x, s = i.p1.y, c = -a(i.p2.y - s, i.p2.x - o), d = function(e) {
-			return {
-				x: (e.x - o) * n(c) - (e.y - s) * r(c),
-				y: (e.x - o) * r(c) + (e.y - s) * n(c)
-			};
-		};
-		return e.map(d);
-	},
-	roots: function(e, r) {
-		r ||= {
-			p1: {
-				x: 0,
-				y: 0
-			},
-			p2: {
-				x: 1,
-				y: 0
-			}
-		};
-		let a = e.length - 1, s = g.align(e, r), reduce = function(e) {
-			return 0 <= e && e <= 1;
-		};
-		if (a === 2) {
-			let e = s[0].y, n = s[1].y, r = s[2].y, i = e - 2 * n + r;
-			if (i !== 0) {
-				let a = -o(n * n - e * r), s = -e + n;
-				return [-(a + s) / i, -(-a + s) / i].filter(reduce);
-			}
-			return n !== r && i === 0 ? [(2 * n - r) / (2 * n - 2 * r)].filter(reduce) : [];
-		}
-		let c = s[0].y, u = s[1].y, f = s[2].y, p = s[3].y, m = -c + 3 * u - 3 * f + p, h = 3 * c - 6 * u + 3 * f, _ = -3 * c + 3 * u, v = c;
-		if (g.approximately(m, 0)) {
-			if (g.approximately(h, 0)) return g.approximately(_, 0) ? [] : [-v / _].filter(reduce);
-			let e = o(_ * _ - 4 * h * v), n = 2 * h;
-			return [(e - _) / n, (-_ - e) / n].filter(reduce);
-		}
-		h /= m, _ /= m, v /= m;
-		let y = (3 * _ - h * h) / 3, b = y / 3, x = (2 * h * h * h - 9 * h * _ + 27 * v) / 27, S = x / 2, C = S * S + b * b * b, w, T, E, D, O;
-		if (C < 0) {
-			let e = -y / 3, r = o(e * e * e), a = -x / (2 * r), s = i(a < -1 ? -1 : a > 1 ? 1 : a), c = 2 * crt(r);
-			return E = c * n(s / 3) - h / 3, D = c * n((s + l) / 3) - h / 3, O = c * n((s + 2 * l) / 3) - h / 3, [
-				E,
-				D,
-				O
-			].filter(reduce);
-		}
-		if (C === 0) return w = S < 0 ? crt(-S) : -crt(S), E = 2 * w - h / 3, D = -w - h / 3, [E, D].filter(reduce);
-		{
-			let e = o(C);
-			return w = crt(-S + e), T = crt(S + e), [w - T - h / 3].filter(reduce);
-		}
-	},
-	droots: function(e) {
-		if (e.length === 3) {
-			let n = e[0], r = e[1], i = e[2], a = n - 2 * r + i;
-			if (a !== 0) {
-				let e = -o(r * r - n * i), s = -n + r;
-				return [-(e + s) / a, -(-e + s) / a];
-			}
-			return r !== i && a === 0 ? [(2 * r - i) / (2 * (r - i))] : [];
-		}
-		if (e.length === 2) {
-			let n = e[0], r = e[1];
-			return n === r ? [] : [n / (n - r)];
-		}
-		return [];
-	},
-	curvature: function(n, r, i, a, c) {
-		let l, u, f, p, m = 0, h = 0, _ = g.compute(n, r), v = g.compute(n, i), y = _.x * _.x + _.y * _.y;
-		if (a ? (l = o(s(_.y * v.z - v.y * _.z, 2) + s(_.z * v.x - v.z * _.x, 2) + s(_.x * v.y - v.x * _.y, 2)), u = s(y + _.z * _.z, 3 / 2)) : (l = _.x * v.y - _.y * v.x, u = s(y, 3 / 2)), l === 0 || u === 0) return {
-			k: 0,
-			r: 0
-		};
-		if (m = l / u, h = u / l, !c) {
-			let o = g.curvature(n - .001, r, i, a, !0).k, s = g.curvature(n + .001, r, i, a, !0).k;
-			p = (s - m + (m - o)) / 2, f = (e(s - m) + e(m - o)) / 2;
-		}
-		return {
-			k: m,
-			r: h,
-			dk: p,
-			adk: f
-		};
-	},
-	inflections: function(e) {
-		if (e.length < 4) return [];
-		let n = g.align(e, {
-			p1: e[0],
-			p2: e.slice(-1)[0]
-		}), r = n[2].x * n[1].y, i = n[3].x * n[1].y, a = n[1].x * n[2].y, o = n[3].x * n[2].y, s = 18 * (-3 * r + 2 * i + 3 * a - o), c = 18 * (3 * r - i - 3 * a), l = 18 * (a - r);
-		if (g.approximately(s, 0)) {
-			if (!g.approximately(c, 0)) {
-				let e = -l / c;
-				if (0 <= e && e <= 1) return [e];
-			}
-			return [];
-		}
-		let u = 2 * s;
-		if (g.approximately(u, 0)) return [];
-		let f = c * c - 4 * s * l;
-		if (f < 0) return [];
-		let p = Math.sqrt(f);
-		return [(p - c) / u, -(c + p) / u].filter(function(e) {
-			return 0 <= e && e <= 1;
-		});
-	},
-	bboxoverlap: function(n, r) {
-		let i = ["x", "y"], a = i.length;
-		for (let o = 0, s, c, l, u; o < a; o++) if (s = i[o], c = n[s].mid, l = r[s].mid, u = (n[s].size + r[s].size) / 2, e(c - l) >= u) return !1;
-		return !0;
-	},
-	expandbox: function(e, n) {
-		n.x.min < e.x.min && (e.x.min = n.x.min), n.y.min < e.y.min && (e.y.min = n.y.min), n.z && n.z.min < e.z.min && (e.z.min = n.z.min), n.x.max > e.x.max && (e.x.max = n.x.max), n.y.max > e.y.max && (e.y.max = n.y.max), n.z && n.z.max > e.z.max && (e.z.max = n.z.max), e.x.mid = (e.x.min + e.x.max) / 2, e.y.mid = (e.y.min + e.y.max) / 2, e.z && (e.z.mid = (e.z.min + e.z.max) / 2), e.x.size = e.x.max - e.x.min, e.y.size = e.y.max - e.y.min, e.z && (e.z.size = e.z.max - e.z.min);
-	},
-	pairiteration: function(e, n, r) {
-		let i = e.bbox(), a = n.bbox(), o = 1e5, s = r || .5;
-		if (i.x.size + i.y.size < s && a.x.size + a.y.size < s) return [(o * (e._t1 + e._t2) / 2 | 0) / o + "/" + (o * (n._t1 + n._t2) / 2 | 0) / o];
-		let c = e.split(.5), l = n.split(.5), u = [
-			{
-				left: c.left,
-				right: l.left
-			},
-			{
-				left: c.left,
-				right: l.right
-			},
-			{
-				left: c.right,
-				right: l.right
-			},
-			{
-				left: c.right,
-				right: l.left
-			}
-		];
-		u = u.filter(function(e) {
-			return g.bboxoverlap(e.left.bbox(), e.right.bbox());
-		});
-		let f = [];
-		return u.length === 0 ? f : (u.forEach(function(e) {
-			f = f.concat(g.pairiteration(e.left, e.right, s));
-		}), f = f.filter(function(e, n) {
-			return f.indexOf(e) === n;
-		}), f);
-	},
-	getccenter: function(e, i, o) {
-		let s = i.x - e.x, c = i.y - e.y, f = o.x - i.x, p = o.y - i.y, m = s * n(u) - c * r(u), h = s * r(u) + c * n(u), _ = f * n(u) - p * r(u), v = f * r(u) + p * n(u), y = (e.x + i.x) / 2, b = (e.y + i.y) / 2, x = (i.x + o.x) / 2, S = (i.y + o.y) / 2, C = y + m, w = b + h, T = x + _, E = S + v, D = g.lli8(y, b, C, w, x, S, T, E), O = g.dist(D, e), k = a(e.y - D.y, e.x - D.x), A = a(i.y - D.y, i.x - D.x), j = a(o.y - D.y, o.x - D.x), M;
-		return k < j ? ((k > A || A > j) && (k += l), k > j && (M = j, j = k, k = M)) : j < A && A < k ? (M = j, j = k, k = M) : j += l, D.s = k, D.e = j, D.r = O, D;
-	},
-	numberSort: function(e, n) {
-		return e - n;
-	}
-}, _ = class PolyBezier {
-	constructor(e) {
-		this.curves = [], this._3d = !1, e && (this.curves = e, this._3d = this.curves[0]._3d);
-	}
-	valueOf() {
-		return this.toString();
-	}
-	toString() {
-		return "[" + this.curves.map(function(e) {
-			return g.pointsToString(e.points);
-		}).join(", ") + "]";
-	}
-	addCurve(e) {
-		this.curves.push(e), this._3d = this._3d || e._3d;
-	}
-	length() {
-		return this.curves.map(function(e) {
-			return e.length();
-		}).reduce(function(e, n) {
-			return e + n;
-		});
-	}
-	curve(e) {
-		return this.curves[e];
-	}
-	bbox() {
-		let e = this.curves;
-		for (var n = e[0].bbox(), r = 1; r < e.length; r++) g.expandbox(n, e[r].bbox());
-		return n;
-	}
-	offset(e) {
-		let n = [];
-		return this.curves.forEach(function(r) {
-			n.push(...r.offset(e));
-		}), new PolyBezier(n);
-	}
-}, { abs: v, min: y, max: b, cos: x, sin: S, acos: C, sqrt: w } = Math, T = Math.PI, E = class Bezier {
-	constructor(e) {
-		let n = e && e.forEach ? e : Array.from(arguments).slice(), r = !1;
-		if (typeof n[0] == "object") {
-			r = n.length;
-			let e = [];
-			n.forEach(function(n) {
-				[
-					"x",
-					"y",
-					"z"
-				].forEach(function(r) {
-					n[r] !== void 0 && e.push(n[r]);
-				});
-			}), n = e;
-		}
-		let i = !1, a = n.length;
-		if (r) {
-			if (r > 4) {
-				if (arguments.length !== 1) throw Error("Only new Bezier(point[]) is accepted for 4th and higher order curves");
-				i = !0;
-			}
-		} else if (a !== 6 && a !== 8 && a !== 9 && a !== 12 && arguments.length !== 1) throw Error("Only new Bezier(point[]) is accepted for 4th and higher order curves");
-		let o = this._3d = !i && (a === 9 || a === 12) || e && e[0] && e[0].z !== void 0, s = this.points = [];
-		for (let e = 0, r = o ? 3 : 2; e < a; e += r) {
-			var c = {
-				x: n[e],
-				y: n[e + 1]
-			};
-			o && (c.z = n[e + 2]), s.push(c);
-		}
-		let l = this.order = s.length - 1, u = this.dims = ["x", "y"];
-		o && u.push("z"), this.dimlen = u.length;
-		let f = g.align(s, {
-			p1: s[0],
-			p2: s[l]
-		}), p = g.dist(s[0], s[l]);
-		this._linear = f.reduce((e, n) => e + v(n.y), 0) < p / 50, this._lut = [], this._t1 = 0, this._t2 = 1, this.update();
-	}
-	static quadraticFromPoints(e, n, r, i) {
-		if (i === void 0 && (i = .5), i === 0) return new Bezier(n, n, r);
-		if (i === 1) return new Bezier(e, n, n);
-		let a = Bezier.getABC(2, e, n, r, i);
-		return new Bezier(e, a.A, r);
-	}
-	static cubicFromPoints(e, n, r, i, a) {
-		i === void 0 && (i = .5);
-		let o = Bezier.getABC(3, e, n, r, i);
-		a === void 0 && (a = g.dist(n, o.C));
-		let s = a * (1 - i) / i, c = g.dist(e, r), l = (r.x - e.x) / c, u = (r.y - e.y) / c, f = a * l, p = a * u, m = s * l, h = s * u, _ = {
-			x: n.x - f,
-			y: n.y - p
-		}, v = {
-			x: n.x + m,
-			y: n.y + h
-		}, y = o.A, b = {
-			x: y.x + (_.x - y.x) / (1 - i),
-			y: y.y + (_.y - y.y) / (1 - i)
-		}, x = {
-			x: y.x + (v.x - y.x) / i,
-			y: y.y + (v.y - y.y) / i
-		}, S = {
-			x: e.x + (b.x - e.x) / i,
-			y: e.y + (b.y - e.y) / i
-		}, C = {
-			x: r.x + (x.x - r.x) / (1 - i),
-			y: r.y + (x.y - r.y) / (1 - i)
-		};
-		return new Bezier(e, S, C, r);
-	}
-	static getUtils() {
-		return g;
-	}
-	getUtils() {
-		return Bezier.getUtils();
-	}
-	static get PolyBezier() {
-		return _;
-	}
-	valueOf() {
-		return this.toString();
-	}
-	toString() {
-		return g.pointsToString(this.points);
-	}
-	toSVG() {
-		if (this._3d) return !1;
-		let e = this.points, n = [
-			"M",
-			e[0].x,
-			e[0].y,
-			this.order === 2 ? "Q" : "C"
-		];
-		for (let r = 1, i = e.length; r < i; r++) n.push(e[r].x), n.push(e[r].y);
-		return n.join(" ");
-	}
-	setRatios(e) {
-		if (e.length !== this.points.length) throw Error("incorrect number of ratio values");
-		this.ratios = e, this._lut = [];
-	}
-	verify() {
-		let e = this.coordDigest();
-		e !== this._print && (this._print = e, this.update());
-	}
-	coordDigest() {
-		return this.points.map(function(e, n) {
-			return "" + n + e.x + e.y + (e.z ? e.z : 0);
-		}).join("");
-	}
-	update() {
-		this._lut = [], this.dpoints = g.derive(this.points, this._3d), this.computedirection();
-	}
-	computedirection() {
-		let e = this.points, n = g.angle(e[0], e[this.order], e[1]);
-		this.clockwise = n > 0;
-	}
-	length() {
-		return g.length(this.derivative.bind(this));
-	}
-	static getABC(e = 2, n, r, i, a = .5) {
-		let o = g.projectionratio(a, e), s = 1 - o, c = {
-			x: o * n.x + s * i.x,
-			y: o * n.y + s * i.y
-		}, l = g.abcratio(a, e);
-		return {
-			A: {
-				x: r.x + (r.x - c.x) / l,
-				y: r.y + (r.y - c.y) / l
-			},
-			B: r,
-			C: c,
-			S: n,
-			E: i
-		};
-	}
-	getABC(e, n) {
-		n ||= this.get(e);
-		let r = this.points[0], i = this.points[this.order];
-		return Bezier.getABC(this.order, r, n, i, e);
-	}
-	getLUT(e) {
-		if (this.verify(), e ||= 100, this._lut.length === e + 1) return this._lut;
-		this._lut = [], e++, this._lut = [];
-		for (let n = 0, r, i; n < e; n++) i = n / (e - 1), r = this.compute(i), r.t = i, this._lut.push(r);
-		return this._lut;
-	}
-	on(e, n) {
-		n ||= 5;
-		let r = this.getLUT(), i = [];
-		for (let a = 0, o, s = 0; a < r.length; a++) o = r[a], g.dist(o, e) < n && (i.push(o), s += a / r.length);
-		return i.length ? t /= i.length : !1;
-	}
-	project(e) {
-		let n = this.getLUT(), r = n.length - 1, i = g.closest(n, e), a = i.mpos, o = (a - 1) / r, s = (a + 1) / r, c = .1 / r, l = i.mdist, u = o, f = u, p;
-		l += 1;
-		for (let n; u < s + c; u += c) p = this.compute(u), n = g.dist(e, p), n < l && (l = n, f = u);
-		return f = f < 0 ? 0 : f > 1 ? 1 : f, p = this.compute(f), p.t = f, p.d = l, p;
-	}
-	get(e) {
-		return this.compute(e);
-	}
-	point(e) {
-		return this.points[e];
-	}
-	compute(e) {
-		return this.ratios ? g.computeWithRatios(e, this.points, this.ratios, this._3d) : g.compute(e, this.points, this._3d, this.ratios);
-	}
-	raise() {
-		let e = this.points, n = [e[0]], r = e.length;
-		for (let i = 1, a, o; i < r; i++) a = e[i], o = e[i - 1], n[i] = {
-			x: (r - i) / r * a.x + i / r * o.x,
-			y: (r - i) / r * a.y + i / r * o.y
-		};
-		return n[r] = e[r - 1], new Bezier(n);
-	}
-	derivative(e) {
-		return g.compute(e, this.dpoints[0], this._3d);
-	}
-	dderivative(e) {
-		return g.compute(e, this.dpoints[1], this._3d);
-	}
-	align() {
-		let e = this.points;
-		return new Bezier(g.align(e, {
-			p1: e[0],
-			p2: e[e.length - 1]
-		}));
-	}
-	curvature(e) {
-		return g.curvature(e, this.dpoints[0], this.dpoints[1], this._3d);
-	}
-	inflections() {
-		return g.inflections(this.points);
-	}
-	normal(e) {
-		return this._3d ? this.__normal3(e) : this.__normal2(e);
-	}
-	__normal2(e) {
-		let n = this.derivative(e), r = w(n.x * n.x + n.y * n.y);
-		return {
-			t: e,
-			x: -n.y / r,
-			y: n.x / r
-		};
-	}
-	__normal3(e) {
-		let n = this.derivative(e), r = this.derivative(e + .01), i = w(n.x * n.x + n.y * n.y + n.z * n.z), a = w(r.x * r.x + r.y * r.y + r.z * r.z);
-		n.x /= i, n.y /= i, n.z /= i, r.x /= a, r.y /= a, r.z /= a;
-		let o = {
-			x: r.y * n.z - r.z * n.y,
-			y: r.z * n.x - r.x * n.z,
-			z: r.x * n.y - r.y * n.x
-		}, s = w(o.x * o.x + o.y * o.y + o.z * o.z);
-		o.x /= s, o.y /= s, o.z /= s;
-		let c = [
-			o.x * o.x,
-			o.x * o.y - o.z,
-			o.x * o.z + o.y,
-			o.x * o.y + o.z,
-			o.y * o.y,
-			o.y * o.z - o.x,
-			o.x * o.z - o.y,
-			o.y * o.z + o.x,
-			o.z * o.z
-		];
-		return {
-			t: e,
-			x: c[0] * n.x + c[1] * n.y + c[2] * n.z,
-			y: c[3] * n.x + c[4] * n.y + c[5] * n.z,
-			z: c[6] * n.x + c[7] * n.y + c[8] * n.z
-		};
-	}
-	hull(e) {
-		let n = this.points, r = [], i = [], a = 0;
-		for (i[a++] = n[0], i[a++] = n[1], i[a++] = n[2], this.order === 3 && (i[a++] = n[3]); n.length > 1;) {
-			r = [];
-			for (let o = 0, s, c = n.length - 1; o < c; o++) s = g.lerp(e, n[o], n[o + 1]), i[a++] = s, r.push(s);
-			n = r;
-		}
-		return i;
-	}
-	split(e, n) {
-		if (e === 0 && n) return this.split(n).left;
-		if (n === 1) return this.split(e).right;
-		let r = this.hull(e), i = {
-			left: this.order === 2 ? new Bezier([
-				r[0],
-				r[3],
-				r[5]
-			]) : new Bezier([
-				r[0],
-				r[4],
-				r[7],
-				r[9]
-			]),
-			right: this.order === 2 ? new Bezier([
-				r[5],
-				r[4],
-				r[2]
-			]) : new Bezier([
-				r[9],
-				r[8],
-				r[6],
-				r[3]
-			]),
-			span: r
-		};
-		return i.left._t1 = g.map(0, 0, 1, this._t1, this._t2), i.left._t2 = g.map(e, 0, 1, this._t1, this._t2), i.right._t1 = g.map(e, 0, 1, this._t1, this._t2), i.right._t2 = g.map(1, 0, 1, this._t1, this._t2), n ? (n = g.map(n, e, 1, 0, 1), i.right.split(n).left) : i;
-	}
-	extrema() {
-		let e = {}, n = [];
-		return this.dims.forEach(function(r) {
-			let mfn = function(e) {
-				return e[r];
-			}, i = this.dpoints[0].map(mfn);
-			e[r] = g.droots(i), this.order === 3 && (i = this.dpoints[1].map(mfn), e[r] = e[r].concat(g.droots(i))), e[r] = e[r].filter(function(e) {
-				return e >= 0 && e <= 1;
-			}), n = n.concat(e[r].sort(g.numberSort));
-		}.bind(this)), e.values = n.sort(g.numberSort).filter(function(e, r) {
-			return n.indexOf(e) === r;
-		}), e;
-	}
-	bbox() {
-		let e = this.extrema(), n = {};
-		return this.dims.forEach(function(r) {
-			n[r] = g.getminmax(this, r, e[r]);
-		}.bind(this)), n;
-	}
-	overlaps(e) {
-		let n = this.bbox(), r = e.bbox();
-		return g.bboxoverlap(n, r);
-	}
-	offset(e, n) {
-		if (n !== void 0) {
-			let r = this.get(e), i = this.normal(e), a = {
-				c: r,
-				n: i,
-				x: r.x + i.x * n,
-				y: r.y + i.y * n
-			};
-			return this._3d && (a.z = r.z + i.z * n), a;
-		}
-		if (this._linear) {
-			let n = this.normal(0), r = this.points.map(function(r) {
-				let i = {
-					x: r.x + e * n.x,
-					y: r.y + e * n.y
-				};
-				return r.z && n.z && (i.z = r.z + e * n.z), i;
-			});
-			return [new Bezier(r)];
-		}
-		return this.reduce().map(function(n) {
-			return n._linear ? n.offset(e)[0] : n.scale(e);
-		});
-	}
-	simple() {
-		if (this.order === 3) {
-			let e = g.angle(this.points[0], this.points[3], this.points[1]), n = g.angle(this.points[0], this.points[3], this.points[2]);
-			if (e > 0 && n < 0 || e < 0 && n > 0) return !1;
-		}
-		let e = this.normal(0), n = this.normal(1), r = e.x * n.x + e.y * n.y;
-		return this._3d && (r += e.z * n.z), v(C(r)) < T / 3;
-	}
-	reduce() {
-		let e, n = 0, r = 0, i = .01, a, o = [], s = [], c = this.extrema().values;
-		for (c.indexOf(0) === -1 && (c = [0].concat(c)), c.indexOf(1) === -1 && c.push(1), n = c[0], e = 1; e < c.length; e++) r = c[e], a = this.split(n, r), a._t1 = n, a._t2 = r, o.push(a), n = r;
-		return o.forEach(function(e) {
-			for (n = 0, r = 0; r <= 1;) for (r = n + i; r <= 1.01; r += i) if (a = e.split(n, r), !a.simple()) {
-				if (r -= i, v(n - r) < i) return [];
-				a = e.split(n, r), a._t1 = g.map(n, 0, 1, e._t1, e._t2), a._t2 = g.map(r, 0, 1, e._t1, e._t2), s.push(a), n = r;
-				break;
-			}
-			n < 1 && (a = e.split(n, 1), a._t1 = g.map(n, 0, 1, e._t1, e._t2), a._t2 = e._t2, s.push(a));
-		}), s;
-	}
-	translate(e, n, r) {
-		r = typeof r == "number" ? r : n;
-		let i = this.order, a = this.points.map((e, a) => (1 - a / i) * n + a / i * r);
-		return new Bezier(this.points.map((n, r) => ({
-			x: n.x + e.x * a[r],
-			y: n.y + e.y * a[r]
-		})));
-	}
-	scale(e) {
-		let n = this.order, r = !1;
-		if (typeof e == "function" && (r = e), r && n === 2) return this.raise().scale(r);
-		let i = this.clockwise, a = this.points;
-		if (this._linear) return this.translate(this.normal(0), r ? r(0) : e, r ? r(1) : e);
-		let o = r ? r(0) : e, s = r ? r(1) : e, c = [this.offset(0, 10), this.offset(1, 10)], l = [], u = g.lli4(c[0], c[0].c, c[1], c[1].c);
-		if (!u) throw Error("cannot scale this curve. Try reducing it first.");
-		return [0, 1].forEach(function(e) {
-			let r = l[e * n] = g.copy(a[e * n]);
-			r.x += (e ? s : o) * c[e].n.x, r.y += (e ? s : o) * c[e].n.y;
-		}), r ? ([0, 1].forEach(function(o) {
-			if (!(n === 2 && o)) {
-				var s = a[o + 1], c = {
-					x: s.x - u.x,
-					y: s.y - u.y
-				}, f = r ? r((o + 1) / n) : e;
-				r && !i && (f = -f);
-				var p = w(c.x * c.x + c.y * c.y);
-				c.x /= p, c.y /= p, l[o + 1] = {
-					x: s.x + f * c.x,
-					y: s.y + f * c.y
-				};
-			}
-		}), new Bezier(l)) : ([0, 1].forEach((e) => {
-			if (n === 2 && e) return;
-			let r = l[e * n], i = this.derivative(e), o = {
-				x: r.x + i.x,
-				y: r.y + i.y
-			};
-			l[e + 1] = g.lli4(r, o, u, a[e + 1]);
-		}), new Bezier(l));
-	}
-	outline(e, n, r, i) {
-		if (n = n === void 0 ? e : n, this._linear) {
-			let a = this.normal(0), o = this.points[0], s = this.points[this.points.length - 1], c, l, u;
-			r === void 0 && (r = e, i = n), c = {
-				x: o.x + a.x * e,
-				y: o.y + a.y * e
-			}, u = {
-				x: s.x + a.x * r,
-				y: s.y + a.y * r
-			}, l = {
-				x: (c.x + u.x) / 2,
-				y: (c.y + u.y) / 2
-			};
-			let f = [
-				c,
-				l,
-				u
-			];
-			c = {
-				x: o.x - a.x * n,
-				y: o.y - a.y * n
-			}, u = {
-				x: s.x - a.x * i,
-				y: s.y - a.y * i
-			}, l = {
-				x: (c.x + u.x) / 2,
-				y: (c.y + u.y) / 2
-			};
-			let p = [
-				u,
-				l,
-				c
-			], m = g.makeline(p[2], f[0]), h = g.makeline(f[2], p[0]);
-			return new _([
-				m,
-				new Bezier(f),
-				h,
-				new Bezier(p)
-			]);
-		}
-		let a = this.reduce(), o = a.length, s = [], c = [], l, u = 0, f = this.length(), p = r !== void 0 && i !== void 0;
-		function linearDistanceFunction(e, n, r, i, a) {
-			return function(o) {
-				let s = i / r, c = (i + a) / r, l = n - e;
-				return g.map(o, 0, 1, e + s * l, e + c * l);
-			};
-		}
-		a.forEach(function(a) {
-			let o = a.length();
-			p ? (s.push(a.scale(linearDistanceFunction(e, r, f, u, o))), c.push(a.scale(linearDistanceFunction(-n, -i, f, u, o)))) : (s.push(a.scale(e)), c.push(a.scale(-n))), u += o;
-		}), c = c.map(function(e) {
-			return l = e.points, e.points = l[3] ? [
-				l[3],
-				l[2],
-				l[1],
-				l[0]
-			] : [
-				l[2],
-				l[1],
-				l[0]
-			], e;
-		}).reverse();
-		let m = s[0].points[0], h = s[o - 1].points[s[o - 1].points.length - 1], v = c[o - 1].points[c[o - 1].points.length - 1], y = c[0].points[0], b = g.makeline(v, m), x = g.makeline(h, y);
-		return new _([b].concat(s, [x], c));
-	}
-	outlineshapes(e, n, r) {
-		n ||= e;
-		let i = this.outline(e, n).curves, a = [];
-		for (let e = 1, n = i.length; e < n / 2; e++) {
-			let o = g.makeshape(i[e], i[n - e], r);
-			o.startcap.virtual = e > 1, o.endcap.virtual = e < n / 2 - 1, a.push(o);
-		}
-		return a;
-	}
-	intersects(e, n) {
-		return e ? e.p1 && e.p2 ? this.lineIntersects(e) : (e instanceof Bezier && (e = e.reduce()), this.curveintersects(this.reduce(), e, n)) : this.selfintersects(n);
-	}
-	lineIntersects(e) {
-		let n = y(e.p1.x, e.p2.x), r = y(e.p1.y, e.p2.y), i = b(e.p1.x, e.p2.x), a = b(e.p1.y, e.p2.y);
-		return g.roots(this.points, e).filter((e) => {
-			var o = this.get(e);
-			return g.between(o.x, n, i) && g.between(o.y, r, a);
-		});
-	}
-	selfintersects(e) {
-		let n = this.reduce(), r = n.length - 2, i = [];
-		for (let a = 0, o, s, c; a < r; a++) s = n.slice(a, a + 1), c = n.slice(a + 2), o = this.curveintersects(s, c, e), i.push(...o);
-		return i;
-	}
-	curveintersects(e, n, r) {
-		let i = [];
-		e.forEach(function(e) {
-			n.forEach(function(n) {
-				e.overlaps(n) && i.push({
-					left: e,
-					right: n
-				});
-			});
-		});
-		let a = [];
-		return i.forEach(function(e) {
-			let n = g.pairiteration(e.left, e.right, r);
-			n.length > 0 && (a = a.concat(n));
-		}), a;
-	}
-	arcs(e) {
-		return e ||= .5, this._iterate(e, []);
-	}
-	_error(e, n, r, i) {
-		let a = (i - r) / 4, o = this.get(r + a), s = this.get(i - a), c = g.dist(e, n), l = g.dist(e, o), u = g.dist(e, s);
-		return v(l - c) + v(u - c);
-	}
-	_iterate(e, n) {
-		let r = 0, i = 1, a;
-		do {
-			a = 0, i = 1;
-			let o = this.get(r), s, c, l, u, f = !1, p = !1, m, h = i, _ = 1, v = 0;
-			do
-				if (p = f, u = l, h = (r + i) / 2, v++, s = this.get(h), c = this.get(i), l = g.getccenter(o, s, c), l.interval = {
-					start: r,
-					end: i
-				}, f = this._error(l, o, r, i) <= e, m = p && !f, m || (_ = i), f) {
-					if (i >= 1) {
-						if (l.interval.end = _ = 1, u = l, i > 1) {
-							let e = {
-								x: l.x + l.r * x(l.e),
-								y: l.y + l.r * S(l.e)
-							};
-							l.e += g.angle({
-								x: l.x,
-								y: l.y
-							}, e, this.get(1));
-						}
-						break;
-					}
-					i += (i - r) / 2;
-				} else i = h;
-			while (!m && a++ < 100);
-			if (a >= 100) break;
-			u ||= l, n.push(u), r = _;
-		} while (i < 1);
-		return n;
-	}
-};
-//#endregion
-export { E as t };