likec4 1.56.0 → 1.58.0

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

@@ -0,0 +1,1003 @@
+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 ? !1 : {
+			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);
+			} else if (n !== r && i === 0) return [(2 * n - r) / (2 * n - 2 * r)].filter(reduce);
+			return [];
+		}
+		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);
+		} else if (C === 0) return w = S < 0 ? crt(-S) : -crt(S), E = 2 * w - h / 3, D = -w - h / 3, [E, D].filter(reduce);
+		else {
+			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];
+			} else if (r !== i && a === 0) return [(2 * r - i) / (2 * (r - i))];
+			return [];
+		}
+		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) {
+		return i === void 0 && (i = .5), i === 0 ? new Bezier(n, n, r) : i === 1 ? new Bezier(e, n, n) : new Bezier(e, Bezier.getABC(2, e, n, r, i).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
+		};
+		return new Bezier(e, {
+			x: e.x + (b.x - e.x) / i,
+			y: e.y + (b.y - e.y) / i
+		}, {
+			x: r.x + (x.x - r.x) / (1 - i),
+			y: r.y + (x.y - r.y) / (1 - i)
+		}, 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);
+			return [new Bezier(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 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, l[3] ? e.points = [
+				l[3],
+				l[2],
+				l[1],
+				l[0]
+			] : e.points = [
+				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 };