likec4 1.59.3 → 1.60.0

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

@@ -1,14 +1,21 @@
 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 { abs: abs$1, cos: cos$1, sin: sin$1, acos: acos$1, atan2, sqrt: sqrt$1, pow } = Math;
+function crt(v) {
+	return v < 0 ? -pow(-v, 1 / 3) : pow(v, 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 = {
+var pi$1 = Math.PI;
+var tau = 2 * pi$1;
+var quart = pi$1 / 2;
+var epsilon = 1e-6;
+var nMax = Number.MAX_SAFE_INTEGER || 9007199254740991;
+var nMin = Number.MIN_SAFE_INTEGER || -9007199254740991;
+var ZERO = {
 	x: 0,
 	y: 0,
 	z: 0
-}, g = {
+};
+var utils = {
 	Tvalues: [
 		-.06405689286260563,
 		.06405689286260563,
@@ -61,250 +68,376 @@ var c = Math.PI, l = 2 * c, u = c / 2, f = 1e-6, p = 2 ** 53 - 1 || 900719925474
 		.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
+	arcfn: function(t, derivativeFn) {
+		const d = derivativeFn(t);
+		let l = d.x * d.x + d.y * d.y;
+		if (typeof d.z !== "undefined") l += d.z * d.z;
+		return sqrt$1(l);
+	},
+	compute: function(t, points, _3d) {
+		if (t === 0) {
+			points[0].t = 0;
+			return points[0];
+		}
+		const order = points.length - 1;
+		if (t === 1) {
+			points[order].t = 1;
+			return points[order];
+		}
+		const mt = 1 - t;
+		let p = points;
+		if (order === 0) {
+			points[0].t = t;
+			return points[0];
+		}
+		if (order === 1) {
+			const ret = {
+				x: mt * p[0].x + t * p[1].x,
+				y: mt * p[0].y + t * p[1].y,
+				t
 			};
-			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
+			if (_3d) ret.z = mt * p[0].z + t * p[1].z;
+			return ret;
+		}
+		if (order < 4) {
+			let mt2 = mt * mt;
+			let t2 = t * t;
+			let a;
+			let b;
+			let c;
+			let d = 0;
+			if (order === 2) {
+				p = [
+					p[0],
+					p[1],
+					p[2],
+					ZERO
+				];
+				a = mt2;
+				b = mt * t * 2;
+				c = t2;
+			} else if (order === 3) {
+				a = mt2 * mt;
+				b = mt2 * t * 3;
+				c = mt * t2 * 3;
+				d = t * t2;
+			}
+			const ret = {
+				x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,
+				y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,
+				t
 			};
-			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
-		};
+			if (_3d) ret.z = a * p[0].z + b * p[1].z + c * p[2].z + d * p[3].z;
+			return ret;
+		}
+		const dCpts = JSON.parse(JSON.stringify(points));
+		while (dCpts.length > 1) {
+			for (let i = 0; i < dCpts.length - 1; i++) {
+				dCpts[i] = {
+					x: dCpts[i].x + (dCpts[i + 1].x - dCpts[i].x) * t,
+					y: dCpts[i].y + (dCpts[i + 1].y - dCpts[i].y) * t
+				};
+				if (typeof dCpts[i].z !== "undefined") dCpts[i].z = dCpts[i].z + (dCpts[i + 1].z - dCpts[i].z) * t;
+			}
+			dCpts.splice(dCpts.length - 1, 1);
+		}
+		dCpts[0].t = t;
+		return dCpts[0];
+	},
+	computeWithRatios: function(t, points, ratios, _3d) {
+		const mt = 1 - t;
+		const r = ratios;
+		const p = points;
+		let f1 = r[0];
+		let f2 = r[1];
+		let f3 = r[2];
+		let f4 = r[3];
+		let d;
+		f1 *= mt;
+		f2 *= t;
+		if (p.length === 2) {
+			d = f1 + f2;
+			return {
+				x: (f1 * p[0].x + f2 * p[1].x) / d,
+				y: (f1 * p[0].y + f2 * p[1].y) / d,
+				z: !_3d ? false : (f1 * p[0].z + f2 * p[1].z) / d,
+				t
+			};
+		}
+		f1 *= mt;
+		f2 *= 2 * mt;
+		f3 *= t * t;
+		if (p.length === 3) {
+			d = f1 + f2 + f3;
+			return {
+				x: (f1 * p[0].x + f2 * p[1].x + f3 * p[2].x) / d,
+				y: (f1 * p[0].y + f2 * p[1].y + f3 * p[2].y) / d,
+				z: !_3d ? false : (f1 * p[0].z + f2 * p[1].z + f3 * p[2].z) / d,
+				t
+			};
+		}
+		f1 *= mt;
+		f2 *= 1.5 * mt;
+		f3 *= 3 * mt;
+		f4 *= t * t * t;
+		if (p.length === 4) {
+			d = f1 + f2 + f3 + f4;
+			return {
+				x: (f1 * p[0].x + f2 * p[1].x + f3 * p[2].x + f4 * p[3].x) / d,
+				y: (f1 * p[0].y + f2 * p[1].y + f3 * p[2].y + f4 * p[3].y) / d,
+				z: !_3d ? false : (f1 * p[0].z + f2 * p[1].z + f3 * p[2].z + f4 * p[3].z) / d,
+				t
+			};
+		}
 	},
-	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)
+	derive: function(points, _3d) {
+		const dpoints = [];
+		for (let p = points, d = p.length, c = d - 1; d > 1; d--, c--) {
+			const list = [];
+			for (let j = 0, dpt; j < c; j++) {
+				dpt = {
+					x: c * (p[j + 1].x - p[j].x),
+					y: c * (p[j + 1].y - p[j].y)
+				};
+				if (_3d) dpt.z = c * (p[j + 1].z - p[j].z);
+				list.push(dpt);
+			}
+			dpoints.push(list);
+			p = list;
+		}
+		return dpoints;
+	},
+	between: function(v, m, M) {
+		return m <= v && v <= M || utils.approximately(v, m) || utils.approximately(v, M);
+	},
+	approximately: function(a, b, precision) {
+		return abs$1(a - b) <= (precision || epsilon);
+	},
+	length: function(derivativeFn) {
+		const z = .5;
+		const len = utils.Tvalues.length;
+		let sum = 0;
+		for (let i = 0, t; i < len; i++) {
+			t = z * utils.Tvalues[i] + z;
+			sum += utils.Cvalues[i] * utils.arcfn(t, derivativeFn);
+		}
+		return z * sum;
+	},
+	map: function(v, ds, de, ts, te) {
+		const d1 = de - ds;
+		return ts + (te - ts) * ((v - ds) / d1);
+	},
+	lerp: function(r, v1, v2) {
+		const ret = {
+			x: v1.x + r * (v2.x - v1.x),
+			y: v1.y + r * (v2.y - v1.y)
 		};
-		return n.z !== void 0 && r.z !== void 0 && (i.z = n.z + e * (r.z - n.z)), i;
+		if (v1.z !== void 0 && v2.z !== void 0) ret.z = v1.z + r * (v2.z - v1.z);
+		return ret;
 	},
-	pointToString: function(e) {
-		let n = e.x + "/" + e.y;
-		return e.z !== void 0 && (n += "/" + e.z), n;
+	pointToString: function(p) {
+		let s = p.x + "/" + p.y;
+		if (typeof p.z !== "undefined") s += "/" + p.z;
+		return s;
 	},
-	pointsToString: function(e) {
-		return "[" + e.map(g.pointToString).join(", ") + "]";
+	pointsToString: function(points) {
+		return "[" + points.map(utils.pointToString).join(", ") + "]";
 	},
-	copy: function(e) {
-		return JSON.parse(JSON.stringify(e));
+	copy: function(obj) {
+		return JSON.parse(JSON.stringify(obj));
 	},
-	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);
+	angle: function(o, v1, v2) {
+		const dx1 = v1.x - o.x;
+		const dy1 = v1.y - o.y;
+		const dx2 = v2.x - o.x;
+		const dy2 = v2.y - o.y;
+		return atan2(dx1 * dy2 - dy1 * dx2, dx1 * dx2 + dy1 * dy2);
 	},
-	round: function(e, n) {
-		let r = "" + e, i = r.indexOf(".");
-		return parseFloat(r.substring(0, i + 1 + n));
+	round: function(v, d) {
+		const s = "" + v;
+		const pos = s.indexOf(".");
+		return parseFloat(s.substring(0, pos + 1 + d));
 	},
-	dist: function(e, n) {
-		let r = e.x - n.x, i = e.y - n.y;
-		return o(r * r + i * i);
+	dist: function(p1, p2) {
+		const dx = p1.x - p2.x;
+		const dy = p1.y - p2.y;
+		return sqrt$1(dx * dx + dy * dy);
 	},
-	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
+	closest: function(LUT, point) {
+		let mdist = pow(2, 63);
+		let mpos;
+		let d;
+		LUT.forEach(function(p, idx) {
+			d = utils.dist(point, p);
+			if (d < mdist) {
+				mdist = d;
+				mpos = idx;
+			}
+		});
+		return {
+			mdist,
+			mpos
 		};
 	},
-	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
+	abcratio: function(t, n) {
+		if (n !== 2 && n !== 3) return false;
+		if (typeof t === "undefined") t = .5;
+		else if (t === 0 || t === 1) return t;
+		const bottom = pow(t, n) + pow(1 - t, n);
+		return abs$1((bottom - 1) / bottom);
+	},
+	projectionratio: function(t, n) {
+		if (n !== 2 && n !== 3) return false;
+		if (typeof t === "undefined") t = .5;
+		else if (t === 0 || t === 1) return t;
+		const top = pow(1 - t, n);
+		return top / (pow(t, n) + top);
+	},
+	lli8: function(x1, y1, x2, y2, x3, y3, x4, y4) {
+		const nx = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4);
+		const ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4);
+		const d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+		if (d == 0) return false;
+		return {
+			x: nx / d,
+			y: ny / d
 		};
 	},
-	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);
+	lli4: function(p1, p2, p3, p4) {
+		const x1 = p1.x;
+		const y1 = p1.y;
+		const x2 = p2.x;
+		const y2 = p2.y;
+		const x3 = p3.x;
+		const y3 = p3.y;
+		const x4 = p4.x;
+		const y4 = p4.y;
+		return utils.lli8(x1, y1, x2, y2, x3, y3, x4, y4);
 	},
-	lli: function(e, n) {
-		return g.lli4(e, e.c, n, n.c);
+	lli: function(v1, v2) {
+		return utils.lli4(v1, v1.c, v2, v2.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);
+	makeline: function(p1, p2) {
+		return new Bezier(p1.x, p1.y, (p1.x + p2.x) / 2, (p1.y + p2.y) / 2, p2.x, p2.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);
-		}), {
+	findbbox: function(sections) {
+		let mx = nMax;
+		let my = nMax;
+		let MX = nMin;
+		let MY = nMin;
+		sections.forEach(function(s) {
+			const bbox = s.bbox();
+			if (mx > bbox.x.min) mx = bbox.x.min;
+			if (my > bbox.y.min) my = bbox.y.min;
+			if (MX < bbox.x.max) MX = bbox.x.max;
+			if (MY < bbox.y.max) MY = bbox.y.max;
+		});
+		return {
 			x: {
-				min: n,
-				mid: (n + i) / 2,
-				max: i,
-				size: i - n
+				min: mx,
+				mid: (mx + MX) / 2,
+				max: MX,
+				size: MX - mx
 			},
 			y: {
-				min: r,
-				mid: (r + a) / 2,
-				max: a,
-				size: a - r
+				min: my,
+				mid: (my + MY) / 2,
+				max: MY,
+				size: MY - my
 			}
 		};
 	},
-	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
+	shapeintersections: function(s1, bbox1, s2, bbox2, curveIntersectionThreshold) {
+		if (!utils.bboxoverlap(bbox1, bbox2)) return [];
+		const intersections = [];
+		const a1 = [
+			s1.startcap,
+			s1.forward,
+			s1.back,
+			s1.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));
+		const a2 = [
+			s2.startcap,
+			s2.forward,
+			s2.back,
+			s2.endcap
+		];
+		a1.forEach(function(l1) {
+			if (l1.virtual) return;
+			a2.forEach(function(l2) {
+				if (l2.virtual) return;
+				const iss = l1.intersects(l2, curveIntersectionThreshold);
+				if (iss.length > 0) {
+					iss.c1 = l1;
+					iss.c2 = l2;
+					iss.s1 = s1;
+					iss.s2 = s2;
+					intersections.push(iss);
+				}
 			});
-		}), 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 intersections;
+	},
+	makeshape: function(forward, back, curveIntersectionThreshold) {
+		const bpl = back.points.length;
+		const fpl = forward.points.length;
+		const start = utils.makeline(back.points[bpl - 1], forward.points[0]);
+		const end = utils.makeline(forward.points[fpl - 1], back.points[0]);
+		const shape = {
+			startcap: start,
+			forward,
+			back,
+			endcap: end,
+			bbox: utils.findbbox([
+				start,
+				forward,
+				back,
+				end
 			])
 		};
-		return c.intersections = function(e) {
-			return g.shapeintersections(c, c.bbox, e, e.bbox, r);
-		}, c;
+		shape.intersections = function(s2) {
+			return utils.shapeintersections(shape, shape.bbox, s2, s2.bbox, curveIntersectionThreshold);
+		};
+		return shape;
 	},
-	getminmax: function(e, n, r) {
-		if (!r) return {
+	getminmax: function(curve, d, list) {
+		if (!list) 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]);
+		let min = nMax;
+		let max = nMin;
+		let t;
+		let c;
+		if (list.indexOf(0) === -1) list = [0].concat(list);
+		if (list.indexOf(1) === -1) list.push(1);
+		for (let i = 0, len = list.length; i < len; i++) {
+			t = list[i];
+			c = curve.get(t);
+			if (c[d] < min) min = c[d];
+			if (c[d] > max) max = c[d];
+		}
 		return {
-			min: i,
-			mid: (i + a) / 2,
-			max: a,
-			size: a - i
+			min,
+			mid: (min + max) / 2,
+			max,
+			size: max - min
 		};
 	},
-	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) {
+	align: function(points, line) {
+		const tx = line.p1.x;
+		const ty = line.p1.y;
+		const a = -atan2(line.p2.y - ty, line.p2.x - tx);
+		const d = function(v) {
 			return {
-				x: (e.x - o) * n(c) - (e.y - s) * r(c),
-				y: (e.x - o) * r(c) + (e.y - s) * n(c)
+				x: (v.x - tx) * cos$1(a) - (v.y - ty) * sin$1(a),
+				y: (v.x - tx) * sin$1(a) + (v.y - ty) * cos$1(a)
 			};
 		};
-		return e.map(d);
+		return points.map(d);
 	},
-	roots: function(e, r) {
-		r ||= {
+	roots: function(points, line) {
+		line = line || {
 			p1: {
 				x: 0,
 				y: 0
@@ -314,694 +447,1147 @@ var c = Math.PI, l = 2 * c, u = c / 2, f = 1e-6, p = 2 ** 53 - 1 || 900719925474
 				y: 0
 			}
 		};
-		let a = e.length - 1, s = g.align(e, r), reduce = function(e) {
-			return 0 <= e && e <= 1;
+		const order = points.length - 1;
+		const aligned = utils.align(points, line);
+		const reduce = function(t) {
+			return 0 <= t && t <= 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);
+		if (order === 2) {
+			const a = aligned[0].y;
+			const b = aligned[1].y;
+			const c = aligned[2].y;
+			const d = a - 2 * b + c;
+			if (d !== 0) {
+				const m1 = -sqrt$1(b * b - a * c);
+				const m2 = -a + b;
+				return [-(m1 + m2) / d, -(-m1 + m2) / d].filter(reduce);
+			} else if (b !== c && d === 0) return [(2 * b - c) / (2 * b - 2 * c)].filter(reduce);
+			return [];
+		}
+		const pa = aligned[0].y;
+		const pb = aligned[1].y;
+		const pc = aligned[2].y;
+		const pd = aligned[3].y;
+		let d = -pa + 3 * pb - 3 * pc + pd;
+		let a = 3 * pa - 6 * pb + 3 * pc;
+		let b = -3 * pa + 3 * pb;
+		let c = pa;
+		if (utils.approximately(d, 0)) {
+			if (utils.approximately(a, 0)) {
+				if (utils.approximately(b, 0)) return [];
+				return [-c / b].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);
+			const q = sqrt$1(b * b - 4 * a * c);
+			const a2 = 2 * a;
+			return [(q - b) / a2, (-b - q) / a2].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);
+		a /= d;
+		b /= d;
+		c /= d;
+		const p = (3 * b - a * a) / 3;
+		const p3 = p / 3;
+		const q = (2 * a * a * a - 9 * a * b + 27 * c) / 27;
+		const q2 = q / 2;
+		const discriminant = q2 * q2 + p3 * p3 * p3;
+		let u1;
+		let v1;
+		let x1;
+		let x2;
+		let x3;
+		if (discriminant < 0) {
+			const mp3 = -p / 3;
+			const r = sqrt$1(mp3 * mp3 * mp3);
+			const t = -q / (2 * r);
+			const phi = acos$1(t < -1 ? -1 : t > 1 ? 1 : t);
+			const t1 = 2 * crt(r);
+			x1 = t1 * cos$1(phi / 3) - a / 3;
+			x2 = t1 * cos$1((phi + tau) / 3) - a / 3;
+			x3 = t1 * cos$1((phi + 2 * tau) / 3) - a / 3;
+			return [
+				x1,
+				x2,
+				x3
+			].filter(reduce);
+		} else if (discriminant === 0) {
+			u1 = q2 < 0 ? crt(-q2) : -crt(q2);
+			x1 = 2 * u1 - a / 3;
+			x2 = -u1 - a / 3;
+			return [x1, x2].filter(reduce);
+		} else {
+			const sd = sqrt$1(discriminant);
+			u1 = crt(-q2 + sd);
+			v1 = crt(q2 + sd);
+			return [u1 - v1 - a / 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))] : [];
+	droots: function(p) {
+		if (p.length === 3) {
+			const a = p[0];
+			const b = p[1];
+			const c = p[2];
+			const d = a - 2 * b + c;
+			if (d !== 0) {
+				const m1 = -sqrt$1(b * b - a * c);
+				const m2 = -a + b;
+				return [-(m1 + m2) / d, -(-m1 + m2) / d];
+			} else if (b !== c && d === 0) return [(2 * b - c) / (2 * (b - c))];
+			return [];
 		}
-		if (e.length === 2) {
-			let n = e[0], r = e[1];
-			return n === r ? [] : [n / (n - r)];
+		if (p.length === 2) {
+			const a = p[0];
+			const b = p[1];
+			if (a !== b) return [a / (a - b)];
+			return [];
 		}
 		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 {
+	curvature: function(t, d1, d2, _3d, kOnly) {
+		let num;
+		let dnm;
+		let adk;
+		let dk;
+		let k = 0;
+		let r = 0;
+		const d = utils.compute(t, d1);
+		const dd = utils.compute(t, d2);
+		const qdsum = d.x * d.x + d.y * d.y;
+		if (_3d) {
+			num = sqrt$1(pow(d.y * dd.z - dd.y * d.z, 2) + pow(d.z * dd.x - dd.z * d.x, 2) + pow(d.x * dd.y - dd.x * d.y, 2));
+			dnm = pow(qdsum + d.z * d.z, 3 / 2);
+		} else {
+			num = d.x * dd.y - d.y * dd.x;
+			dnm = pow(qdsum, 3 / 2);
+		}
+		if (num === 0 || dnm === 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;
+		k = num / dnm;
+		r = dnm / num;
+		if (!kOnly) {
+			const pk = utils.curvature(t - .001, d1, d2, _3d, true).k;
+			const nk = utils.curvature(t + .001, d1, d2, _3d, true).k;
+			dk = (nk - k + (k - pk)) / 2;
+			adk = (abs$1(nk - k) + abs$1(k - pk)) / 2;
 		}
 		return {
-			k: m,
-			r: h,
-			dk: p,
-			adk: f
+			k,
+			r,
+			dk,
+			adk
 		};
 	},
-	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];
+	inflections: function(points) {
+		if (points.length < 4) return [];
+		const p = utils.align(points, {
+			p1: points[0],
+			p2: points.slice(-1)[0]
+		});
+		const a = p[2].x * p[1].y;
+		const b = p[3].x * p[1].y;
+		const c = p[1].x * p[2].y;
+		const d = p[3].x * p[2].y;
+		const v1 = 18 * (-3 * a + 2 * b + 3 * c - d);
+		const v2 = 18 * (3 * a - b - 3 * c);
+		const v3 = 18 * (c - a);
+		if (utils.approximately(v1, 0)) {
+			if (!utils.approximately(v2, 0)) {
+				let t = -v3 / v2;
+				if (0 <= t && t <= 1) return [t];
 			}
 			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;
+		const d2 = 2 * v1;
+		if (utils.approximately(d2, 0)) return [];
+		const trm = v2 * v2 - 4 * v1 * v3;
+		if (trm < 0) return [];
+		const sq = Math.sqrt(trm);
+		return [(sq - v2) / d2, -(v2 + sq) / d2].filter(function(r) {
+			return 0 <= r && r <= 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;
+	bboxoverlap: function(b1, b2) {
+		const dims = ["x", "y"];
+		const len = dims.length;
+		for (let i = 0, dim, l, t, d; i < len; i++) {
+			dim = dims[i];
+			l = b1[dim].mid;
+			t = b2[dim].mid;
+			d = (b1[dim].size + b2[dim].size) / 2;
+			if (abs$1(l - t) >= d) return false;
+		}
+		return true;
 	},
-	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);
+	expandbox: function(bbox, _bbox) {
+		if (_bbox.x.min < bbox.x.min) bbox.x.min = _bbox.x.min;
+		if (_bbox.y.min < bbox.y.min) bbox.y.min = _bbox.y.min;
+		if (_bbox.z && _bbox.z.min < bbox.z.min) bbox.z.min = _bbox.z.min;
+		if (_bbox.x.max > bbox.x.max) bbox.x.max = _bbox.x.max;
+		if (_bbox.y.max > bbox.y.max) bbox.y.max = _bbox.y.max;
+		if (_bbox.z && _bbox.z.max > bbox.z.max) bbox.z.max = _bbox.z.max;
+		bbox.x.mid = (bbox.x.min + bbox.x.max) / 2;
+		bbox.y.mid = (bbox.y.min + bbox.y.max) / 2;
+		if (bbox.z) bbox.z.mid = (bbox.z.min + bbox.z.max) / 2;
+		bbox.x.size = bbox.x.max - bbox.x.min;
+		bbox.y.size = bbox.y.max - bbox.y.min;
+		if (bbox.z) bbox.z.size = bbox.z.max - bbox.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 = [
+	pairiteration: function(c1, c2, curveIntersectionThreshold) {
+		const c1b = c1.bbox();
+		const c2b = c2.bbox();
+		const r = 1e5;
+		const threshold = curveIntersectionThreshold || .5;
+		if (c1b.x.size + c1b.y.size < threshold && c2b.x.size + c2b.y.size < threshold) return [(r * (c1._t1 + c1._t2) / 2 | 0) / r + "/" + (r * (c2._t1 + c2._t2) / 2 | 0) / r];
+		let cc1 = c1.split(.5);
+		let cc2 = c2.split(.5);
+		let pairs = [
 			{
-				left: c.left,
-				right: l.left
+				left: cc1.left,
+				right: cc2.left
 			},
 			{
-				left: c.left,
-				right: l.right
+				left: cc1.left,
+				right: cc2.right
 			},
 			{
-				left: c.right,
-				right: l.right
+				left: cc1.right,
+				right: cc2.right
 			},
 			{
-				left: c.right,
-				right: l.left
+				left: cc1.right,
+				right: cc2.left
 			}
 		];
-		u = u.filter(function(e) {
-			return g.bboxoverlap(e.left.bbox(), e.right.bbox());
+		pairs = pairs.filter(function(pair) {
+			return utils.bboxoverlap(pair.left.bbox(), pair.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);
+		let results = [];
+		if (pairs.length === 0) return results;
+		pairs.forEach(function(pair) {
+			results = results.concat(utils.pairiteration(pair.left, pair.right, threshold));
+		});
+		results = results.filter(function(v, i) {
+			return results.indexOf(v) === i;
+		});
+		return results;
 	},
-	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;
+	getccenter: function(p1, p2, p3) {
+		const dx1 = p2.x - p1.x;
+		const dy1 = p2.y - p1.y;
+		const dx2 = p3.x - p2.x;
+		const dy2 = p3.y - p2.y;
+		const dx1p = dx1 * cos$1(quart) - dy1 * sin$1(quart);
+		const dy1p = dx1 * sin$1(quart) + dy1 * cos$1(quart);
+		const dx2p = dx2 * cos$1(quart) - dy2 * sin$1(quart);
+		const dy2p = dx2 * sin$1(quart) + dy2 * cos$1(quart);
+		const mx1 = (p1.x + p2.x) / 2;
+		const my1 = (p1.y + p2.y) / 2;
+		const mx2 = (p2.x + p3.x) / 2;
+		const my2 = (p2.y + p3.y) / 2;
+		const mx1n = mx1 + dx1p;
+		const my1n = my1 + dy1p;
+		const mx2n = mx2 + dx2p;
+		const my2n = my2 + dy2p;
+		const arc = utils.lli8(mx1, my1, mx1n, my1n, mx2, my2, mx2n, my2n);
+		const r = utils.dist(arc, p1);
+		let s = atan2(p1.y - arc.y, p1.x - arc.x);
+		let m = atan2(p2.y - arc.y, p2.x - arc.x);
+		let e = atan2(p3.y - arc.y, p3.x - arc.x);
+		let _;
+		if (s < e) {
+			if (s > m || m > e) s += tau;
+			if (s > e) {
+				_ = e;
+				e = s;
+				s = _;
+			}
+		} else if (e < m && m < s) {
+			_ = e;
+			e = s;
+			s = _;
+		} else e += tau;
+		arc.s = s;
+		arc.e = e;
+		arc.r = r;
+		return arc;
 	},
-	numberSort: function(e, n) {
-		return e - n;
+	numberSort: function(a, b) {
+		return a - b;
 	}
-}, _ = class PolyBezier {
-	constructor(e) {
-		this.curves = [], this._3d = !1, e && (this.curves = e, this._3d = this.curves[0]._3d);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bezier-js@6.1.4/node_modules/bezier-js/src/poly-bezier.js
+/**
+* Poly Bezier
+* @param {[type]} curves [description]
+*/
+var PolyBezier = class PolyBezier {
+	constructor(curves) {
+		this.curves = [];
+		this._3d = false;
+		if (!!curves) {
+			this.curves = curves;
+			this._3d = this.curves[0]._3d;
+		}
 	}
 	valueOf() {
 		return this.toString();
 	}
 	toString() {
-		return "[" + this.curves.map(function(e) {
-			return g.pointsToString(e.points);
+		return "[" + this.curves.map(function(curve) {
+			return utils.pointsToString(curve.points);
 		}).join(", ") + "]";
 	}
-	addCurve(e) {
-		this.curves.push(e), this._3d = this._3d || e._3d;
+	addCurve(curve) {
+		this.curves.push(curve);
+		this._3d = this._3d || curve._3d;
 	}
 	length() {
-		return this.curves.map(function(e) {
-			return e.length();
-		}).reduce(function(e, n) {
-			return e + n;
+		return this.curves.map(function(v) {
+			return v.length();
+		}).reduce(function(a, b) {
+			return a + b;
 		});
 	}
-	curve(e) {
-		return this.curves[e];
+	curve(idx) {
+		return this.curves[idx];
 	}
 	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) {
+		const c = this.curves;
+		var bbox = c[0].bbox();
+		for (var i = 1; i < c.length; i++) utils.expandbox(bbox, c[i].bbox());
+		return bbox;
+	}
+	offset(d) {
+		const offset = [];
+		this.curves.forEach(function(v) {
+			offset.push(...v.offset(d));
+		});
+		return new PolyBezier(offset);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bezier-js@6.1.4/node_modules/bezier-js/src/bezier.js
+/**
+A javascript Bezier curve library by Pomax.
+
+Based on http://pomax.github.io/bezierinfo
+
+This code is MIT licensed.
+**/
+var { abs, min, max, cos, sin, acos, sqrt } = Math;
+var pi = Math.PI;
+/**
+* Bezier curve constructor.
+*
+* ...docs pending...
+*/
+var Bezier = class Bezier {
+	constructor(coords) {
+		let args = coords && coords.forEach ? coords : Array.from(arguments).slice();
+		let coordlen = false;
+		if (typeof args[0] === "object") {
+			coordlen = args.length;
+			const newargs = [];
+			args.forEach(function(point) {
 				[
 					"x",
 					"y",
 					"z"
-				].forEach(function(r) {
-					n[r] !== void 0 && e.push(n[r]);
+				].forEach(function(d) {
+					if (typeof point[d] !== "undefined") newargs.push(point[d]);
 				});
-			}), n = e;
+			});
+			args = newargs;
 		}
-		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;
+		let higher = false;
+		const len = args.length;
+		if (coordlen) {
+			if (coordlen > 4) {
+				if (arguments.length !== 1) throw new Error("Only new Bezier(point[]) is accepted for 4th and higher order curves");
+				higher = true;
 			}
-		} 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]
+		} else if (len !== 6 && len !== 8 && len !== 9 && len !== 12) {
+			if (arguments.length !== 1) throw new Error("Only new Bezier(point[]) is accepted for 4th and higher order curves");
+		}
+		const _3d = this._3d = !higher && (len === 9 || len === 12) || coords && coords[0] && typeof coords[0].z !== "undefined";
+		const points = this.points = [];
+		for (let idx = 0, step = _3d ? 3 : 2; idx < len; idx += step) {
+			var point = {
+				x: args[idx],
+				y: args[idx + 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)
+			if (_3d) point.z = args[idx + 2];
+			points.push(point);
+		}
+		const order = this.order = points.length - 1;
+		const dims = this.dims = ["x", "y"];
+		if (_3d) dims.push("z");
+		this.dimlen = dims.length;
+		const aligned = utils.align(points, {
+			p1: points[0],
+			p2: points[order]
+		});
+		const baselength = utils.dist(points[0], points[order]);
+		this._linear = aligned.reduce((t, p) => t + abs(p.y), 0) < baselength / 50;
+		this._lut = [];
+		this._t1 = 0;
+		this._t2 = 1;
+		this.update();
+	}
+	static quadraticFromPoints(p1, p2, p3, t) {
+		if (typeof t === "undefined") t = .5;
+		if (t === 0) return new Bezier(p2, p2, p3);
+		if (t === 1) return new Bezier(p1, p2, p2);
+		const abc = Bezier.getABC(2, p1, p2, p3, t);
+		return new Bezier(p1, abc.A, p3);
+	}
+	static cubicFromPoints(S, B, E, t, d1) {
+		if (typeof t === "undefined") t = .5;
+		const abc = Bezier.getABC(3, S, B, E, t);
+		if (typeof d1 === "undefined") d1 = utils.dist(B, abc.C);
+		const d2 = d1 * (1 - t) / t;
+		const selen = utils.dist(S, E);
+		const lx = (E.x - S.x) / selen;
+		const ly = (E.y - S.y) / selen;
+		const bx1 = d1 * lx;
+		const by1 = d1 * ly;
+		const bx2 = d2 * lx;
+		const by2 = d2 * ly;
+		const e1 = {
+			x: B.x - bx1,
+			y: B.y - by1
 		};
-		return new Bezier(e, S, C, r);
+		const e2 = {
+			x: B.x + bx2,
+			y: B.y + by2
+		};
+		const A = abc.A;
+		const v1 = {
+			x: A.x + (e1.x - A.x) / (1 - t),
+			y: A.y + (e1.y - A.y) / (1 - t)
+		};
+		const v2 = {
+			x: A.x + (e2.x - A.x) / t,
+			y: A.y + (e2.y - A.y) / t
+		};
+		const nc1 = {
+			x: S.x + (v1.x - S.x) / t,
+			y: S.y + (v1.y - S.y) / t
+		};
+		const nc2 = {
+			x: E.x + (v2.x - E.x) / (1 - t),
+			y: E.y + (v2.y - E.y) / (1 - t)
+		};
+		return new Bezier(S, nc1, nc2, E);
 	}
 	static getUtils() {
-		return g;
+		return utils;
 	}
 	getUtils() {
 		return Bezier.getUtils();
 	}
 	static get PolyBezier() {
-		return _;
+		return PolyBezier;
 	}
 	valueOf() {
 		return this.toString();
 	}
 	toString() {
-		return g.pointsToString(this.points);
+		return utils.pointsToString(this.points);
 	}
 	toSVG() {
-		if (this._3d) return !1;
-		let e = this.points, n = [
+		if (this._3d) return false;
+		const p = this.points;
+		const s = [
 			"M",
-			e[0].x,
-			e[0].y,
+			p[0].x,
+			p[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(" ");
+		for (let i = 1, last = p.length; i < last; i++) {
+			s.push(p[i].x);
+			s.push(p[i].y);
+		}
+		return s.join(" ");
 	}
-	setRatios(e) {
-		if (e.length !== this.points.length) throw Error("incorrect number of ratio values");
-		this.ratios = e, this._lut = [];
+	setRatios(ratios) {
+		if (ratios.length !== this.points.length) throw new Error("incorrect number of ratio values");
+		this.ratios = ratios;
+		this._lut = [];
 	}
 	verify() {
-		let e = this.coordDigest();
-		e !== this._print && (this._print = e, this.update());
+		const print = this.coordDigest();
+		if (print !== this._print) {
+			this._print = print;
+			this.update();
+		}
 	}
 	coordDigest() {
-		return this.points.map(function(e, n) {
-			return "" + n + e.x + e.y + (e.z ? e.z : 0);
+		return this.points.map(function(c, pos) {
+			return "" + pos + c.x + c.y + (c.z ? c.z : 0);
 		}).join("");
 	}
 	update() {
-		this._lut = [], this.dpoints = g.derive(this.points, this._3d), this.computedirection();
+		this._lut = [];
+		this.dpoints = utils.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;
+		const points = this.points;
+		const angle = utils.angle(points[0], points[this.order], points[1]);
+		this.clockwise = angle > 0;
 	}
 	length() {
-		return g.length(this.derivative.bind(this));
+		return utils.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);
+	static getABC(order = 2, S, B, E, t = .5) {
+		const u = utils.projectionratio(t, order);
+		const um = 1 - u;
+		const C = {
+			x: u * S.x + um * E.x,
+			y: u * S.y + um * E.y
+		};
+		const s = utils.abcratio(t, order);
 		return {
 			A: {
-				x: r.x + (r.x - c.x) / l,
-				y: r.y + (r.y - c.y) / l
+				x: B.x + (B.x - C.x) / s,
+				y: B.y + (B.y - C.y) / s
 			},
-			B: r,
-			C: c,
-			S: n,
-			E: i
+			B,
+			C,
+			S,
+			E
 		};
 	}
-	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);
+	getABC(t, B) {
+		B = B || this.get(t);
+		let S = this.points[0];
+		let E = this.points[this.order];
+		return Bezier.getABC(this.order, S, B, E, t);
 	}
-	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);
+	getLUT(steps) {
+		this.verify();
+		steps = steps || 100;
+		if (this._lut.length === steps + 1) return this._lut;
+		this._lut = [];
+		steps++;
+		this._lut = [];
+		for (let i = 0, p, t; i < steps; i++) {
+			t = i / (steps - 1);
+			p = this.compute(t);
+			p.t = t;
+			this._lut.push(p);
+		}
 		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;
+	on(point, error) {
+		error = error || 5;
+		const lut = this.getLUT();
+		const hits = [];
+		for (let i = 0, c, t = 0; i < lut.length; i++) {
+			c = lut[i];
+			if (utils.dist(c, point) < error) {
+				hits.push(c);
+				t += i / lut.length;
+			}
+		}
+		if (!hits.length) return false;
+		return t /= hits.length;
 	}
-	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;
+	project(point) {
+		const LUT = this.getLUT();
+		const l = LUT.length - 1;
+		const closest = utils.closest(LUT, point);
+		const mpos = closest.mpos;
+		const t1 = (mpos - 1) / l;
+		const t2 = (mpos + 1) / l;
+		const step = .1 / l;
+		let mdist = closest.mdist;
+		let t = t1;
+		let ft = t;
+		let p;
+		mdist += 1;
+		for (let d; t < t2 + step; t += step) {
+			p = this.compute(t);
+			d = utils.dist(point, p);
+			if (d < mdist) {
+				mdist = d;
+				ft = t;
+			}
+		}
+		ft = ft < 0 ? 0 : ft > 1 ? 1 : ft;
+		p = this.compute(ft);
+		p.t = ft;
+		p.d = mdist;
+		return p;
 	}
-	get(e) {
-		return this.compute(e);
+	get(t) {
+		return this.compute(t);
 	}
-	point(e) {
-		return this.points[e];
+	point(idx) {
+		return this.points[idx];
 	}
-	compute(e) {
-		return this.ratios ? g.computeWithRatios(e, this.points, this.ratios, this._3d) : g.compute(e, this.points, this._3d, this.ratios);
+	compute(t) {
+		if (this.ratios) return utils.computeWithRatios(t, this.points, this.ratios, this._3d);
+		return utils.compute(t, 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);
+		const p = this.points;
+		const np = [p[0]];
+		const k = p.length;
+		for (let i = 1, pi, pim; i < k; i++) {
+			pi = p[i];
+			pim = p[i - 1];
+			np[i] = {
+				x: (k - i) / k * pi.x + i / k * pim.x,
+				y: (k - i) / k * pi.y + i / k * pim.y
+			};
+		}
+		np[k] = p[k - 1];
+		return new Bezier(np);
 	}
-	derivative(e) {
-		return g.compute(e, this.dpoints[0], this._3d);
+	derivative(t) {
+		return utils.compute(t, this.dpoints[0], this._3d);
 	}
-	dderivative(e) {
-		return g.compute(e, this.dpoints[1], this._3d);
+	dderivative(t) {
+		return utils.compute(t, this.dpoints[1], this._3d);
 	}
 	align() {
-		let e = this.points;
-		return new Bezier(g.align(e, {
-			p1: e[0],
-			p2: e[e.length - 1]
+		let p = this.points;
+		return new Bezier(utils.align(p, {
+			p1: p[0],
+			p2: p[p.length - 1]
 		}));
 	}
-	curvature(e) {
-		return g.curvature(e, this.dpoints[0], this.dpoints[1], this._3d);
+	curvature(t) {
+		return utils.curvature(t, this.dpoints[0], this.dpoints[1], this._3d);
 	}
 	inflections() {
-		return g.inflections(this.points);
+		return utils.inflections(this.points);
 	}
-	normal(e) {
-		return this._3d ? this.__normal3(e) : this.__normal2(e);
+	normal(t) {
+		return this._3d ? this.__normal3(t) : this.__normal2(t);
 	}
-	__normal2(e) {
-		let n = this.derivative(e), r = w(n.x * n.x + n.y * n.y);
+	__normal2(t) {
+		const d = this.derivative(t);
+		const q = sqrt(d.x * d.x + d.y * d.y);
 		return {
-			t: e,
-			x: -n.y / r,
-			y: n.x / r
+			t,
+			x: -d.y / q,
+			y: d.x / q
 		};
 	}
-	__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
+	__normal3(t) {
+		const r1 = this.derivative(t);
+		const r2 = this.derivative(t + .01);
+		const q1 = sqrt(r1.x * r1.x + r1.y * r1.y + r1.z * r1.z);
+		const q2 = sqrt(r2.x * r2.x + r2.y * r2.y + r2.z * r2.z);
+		r1.x /= q1;
+		r1.y /= q1;
+		r1.z /= q1;
+		r2.x /= q2;
+		r2.y /= q2;
+		r2.z /= q2;
+		const c = {
+			x: r2.y * r1.z - r2.z * r1.y,
+			y: r2.z * r1.x - r2.x * r1.z,
+			z: r2.x * r1.y - r2.y * r1.x
+		};
+		const m = sqrt(c.x * c.x + c.y * c.y + c.z * c.z);
+		c.x /= m;
+		c.y /= m;
+		c.z /= m;
+		const R = [
+			c.x * c.x,
+			c.x * c.y - c.z,
+			c.x * c.z + c.y,
+			c.x * c.y + c.z,
+			c.y * c.y,
+			c.y * c.z - c.x,
+			c.x * c.z - c.y,
+			c.y * c.z + c.x,
+			c.z * c.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
+			t,
+			x: R[0] * r1.x + R[1] * r1.y + R[2] * r1.z,
+			y: R[3] * r1.x + R[4] * r1.y + R[5] * r1.z,
+			z: R[6] * r1.x + R[7] * r1.y + R[8] * r1.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;
+	hull(t) {
+		let p = this.points;
+		let _p = [];
+		let q = [];
+		let idx = 0;
+		q[idx++] = p[0];
+		q[idx++] = p[1];
+		q[idx++] = p[2];
+		if (this.order === 3) q[idx++] = p[3];
+		while (p.length > 1) {
+			_p = [];
+			for (let i = 0, pt, l = p.length - 1; i < l; i++) {
+				pt = utils.lerp(t, p[i], p[i + 1]);
+				q[idx++] = pt;
+				_p.push(pt);
+			}
+			p = _p;
 		}
-		return i;
+		return q;
 	}
-	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 = {
+	split(t1, t2) {
+		if (t1 === 0 && !!t2) return this.split(t2).left;
+		if (t2 === 1) return this.split(t1).right;
+		const q = this.hull(t1);
+		const result = {
 			left: this.order === 2 ? new Bezier([
-				r[0],
-				r[3],
-				r[5]
+				q[0],
+				q[3],
+				q[5]
 			]) : new Bezier([
-				r[0],
-				r[4],
-				r[7],
-				r[9]
+				q[0],
+				q[4],
+				q[7],
+				q[9]
 			]),
 			right: this.order === 2 ? new Bezier([
-				r[5],
-				r[4],
-				r[2]
+				q[5],
+				q[4],
+				q[2]
 			]) : new Bezier([
-				r[9],
-				r[8],
-				r[6],
-				r[3]
+				q[9],
+				q[8],
+				q[6],
+				q[3]
 			]),
-			span: r
+			span: q
 		};
-		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;
+		result.left._t1 = utils.map(0, 0, 1, this._t1, this._t2);
+		result.left._t2 = utils.map(t1, 0, 1, this._t1, this._t2);
+		result.right._t1 = utils.map(t1, 0, 1, this._t1, this._t2);
+		result.right._t2 = utils.map(1, 0, 1, this._t1, this._t2);
+		if (!t2) return result;
+		t2 = utils.map(t2, t1, 1, 0, 1);
+		return result.right.split(t2).left;
 	}
 	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;
+		const result = {};
+		let roots = [];
+		this.dims.forEach(function(dim) {
+			let mfn = function(v) {
+				return v[dim];
+			};
+			let p = this.dpoints[0].map(mfn);
+			result[dim] = utils.droots(p);
+			if (this.order === 3) {
+				p = this.dpoints[1].map(mfn);
+				result[dim] = result[dim].concat(utils.droots(p));
+			}
+			result[dim] = result[dim].filter(function(t) {
+				return t >= 0 && t <= 1;
+			});
+			roots = roots.concat(result[dim].sort(utils.numberSort));
+		}.bind(this));
+		result.values = roots.sort(utils.numberSort).filter(function(v, idx) {
+			return roots.indexOf(v) === idx;
+		});
+		return result;
 	}
 	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
+		const extrema = this.extrema();
+		const result = {};
+		this.dims.forEach(function(d) {
+			result[d] = utils.getminmax(this, d, extrema[d]);
+		}.bind(this));
+		return result;
+	}
+	overlaps(curve) {
+		const lbbox = this.bbox();
+		const tbbox = curve.bbox();
+		return utils.bboxoverlap(lbbox, tbbox);
+	}
+	offset(t, d) {
+		if (typeof d !== "undefined") {
+			const c = this.get(t);
+			const n = this.normal(t);
+			const ret = {
+				c,
+				n,
+				x: c.x + n.x * d,
+				y: c.y + n.y * d
 			};
-			return this._3d && (a.z = r.z + i.z * n), a;
+			if (this._3d) ret.z = c.z + n.z * d;
+			return ret;
 		}
 		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
+			const nv = this.normal(0);
+			const coords = this.points.map(function(p) {
+				const ret = {
+					x: p.x + t * nv.x,
+					y: p.y + t * nv.y
 				};
-				return r.z && n.z && (i.z = r.z + e * n.z), i;
+				if (p.z && nv.z) ret.z = p.z + t * nv.z;
+				return ret;
 			});
-			return [new Bezier(r)];
+			return [new Bezier(coords)];
 		}
-		return this.reduce().map(function(n) {
-			return n._linear ? n.offset(e)[0] : n.scale(e);
+		return this.reduce().map(function(s) {
+			if (s._linear) return s.offset(t)[0];
+			return s.scale(t);
 		});
 	}
 	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;
+			const a1 = utils.angle(this.points[0], this.points[3], this.points[1]);
+			const a2 = utils.angle(this.points[0], this.points[3], this.points[2]);
+			if (a1 > 0 && a2 < 0 || a1 < 0 && a2 > 0) return false;
 		}
-		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;
+		const n1 = this.normal(0);
+		const n2 = this.normal(1);
+		let s = n1.x * n2.x + n1.y * n2.y;
+		if (this._3d) s += n1.z * n2.z;
+		return abs(acos(s)) < pi / 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;
+		let i;
+		let t1 = 0;
+		let t2 = 0;
+		let step = .01;
+		let segment;
+		let pass1 = [];
+		let pass2 = [];
+		let extrema = this.extrema().values;
+		if (extrema.indexOf(0) === -1) extrema = [0].concat(extrema);
+		if (extrema.indexOf(1) === -1) extrema.push(1);
+		for (t1 = extrema[0], i = 1; i < extrema.length; i++) {
+			t2 = extrema[i];
+			segment = this.split(t1, t2);
+			segment._t1 = t1;
+			segment._t2 = t2;
+			pass1.push(segment);
+			t1 = t2;
+		}
+		pass1.forEach(function(p1) {
+			t1 = 0;
+			t2 = 0;
+			while (t2 <= 1) for (t2 = t1 + step; t2 <= 1.01; t2 += step) {
+				segment = p1.split(t1, t2);
+				if (!segment.simple()) {
+					t2 -= step;
+					if (abs(t1 - t2) < step) return [];
+					segment = p1.split(t1, t2);
+					segment._t1 = utils.map(t1, 0, 1, p1._t1, p1._t2);
+					segment._t2 = utils.map(t2, 0, 1, p1._t1, p1._t2);
+					pass2.push(segment);
+					t1 = t2;
+					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]
+			if (t1 < 1) {
+				segment = p1.split(t1, 1);
+				segment._t1 = utils.map(t1, 0, 1, p1._t1, p1._t2);
+				segment._t2 = p1._t2;
+				pass2.push(segment);
+			}
+		});
+		return pass2;
+	}
+	translate(v, d1, d2) {
+		d2 = typeof d2 === "number" ? d2 : d1;
+		const o = this.order;
+		let d = this.points.map((_, i) => (1 - i / o) * d1 + i / o * d2);
+		return new Bezier(this.points.map((p, i) => ({
+			x: p.x + v.x * d[i],
+			y: p.y + v.y * d[i]
 		})));
 	}
-	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
+	scale(d) {
+		const order = this.order;
+		let distanceFn = false;
+		if (typeof d === "function") distanceFn = d;
+		if (distanceFn && order === 2) return this.raise().scale(distanceFn);
+		const clockwise = this.clockwise;
+		const points = this.points;
+		if (this._linear) return this.translate(this.normal(0), distanceFn ? distanceFn(0) : d, distanceFn ? distanceFn(1) : d);
+		const r1 = distanceFn ? distanceFn(0) : d;
+		const r2 = distanceFn ? distanceFn(1) : d;
+		const v = [this.offset(0, 10), this.offset(1, 10)];
+		const np = [];
+		const o = utils.lli4(v[0], v[0].c, v[1], v[1].c);
+		if (!o) throw new Error("cannot scale this curve. Try reducing it first.");
+		[0, 1].forEach(function(t) {
+			const p = np[t * order] = utils.copy(points[t * order]);
+			p.x += (t ? r2 : r1) * v[t].n.x;
+			p.y += (t ? r2 : r1) * v[t].n.y;
+		});
+		if (!distanceFn) {
+			[0, 1].forEach((t) => {
+				if (order === 2 && !!t) return;
+				const p = np[t * order];
+				const d = this.derivative(t);
+				const p2 = {
+					x: p.x + d.x,
+					y: p.y + d.y
 				};
+				np[t + 1] = utils.lli4(p, p2, o, points[t + 1]);
+			});
+			return new Bezier(np);
+		}
+		[0, 1].forEach(function(t) {
+			if (order === 2 && !!t) return;
+			var p = points[t + 1];
+			var ov = {
+				x: p.x - o.x,
+				y: p.y - o.y
+			};
+			var rc = distanceFn ? distanceFn((t + 1) / order) : d;
+			if (distanceFn && !clockwise) rc = -rc;
+			var m = sqrt(ov.x * ov.x + ov.y * ov.y);
+			ov.x /= m;
+			ov.y /= m;
+			np[t + 1] = {
+				x: p.x + rc * ov.x,
+				y: p.y + rc * ov.y
+			};
+		});
+		return new Bezier(np);
+	}
+	outline(d1, d2, d3, d4) {
+		d2 = d2 === void 0 ? d1 : d2;
+		if (this._linear) {
+			const n = this.normal(0);
+			const start = this.points[0];
+			const end = this.points[this.points.length - 1];
+			let s;
+			let mid;
+			let e;
+			if (d3 === void 0) {
+				d3 = d1;
+				d4 = d2;
 			}
-		}), 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
+			s = {
+				x: start.x + n.x * d1,
+				y: start.y + n.y * d1
 			};
-			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
+			e = {
+				x: end.x + n.x * d3,
+				y: end.y + n.y * d3
 			};
-			let f = [
-				c,
-				l,
-				u
+			mid = {
+				x: (s.x + e.x) / 2,
+				y: (s.y + e.y) / 2
+			};
+			const fline = [
+				s,
+				mid,
+				e
 			];
-			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
+			s = {
+				x: start.x - n.x * d2,
+				y: start.y - n.y * d2
+			};
+			e = {
+				x: end.x - n.x * d4,
+				y: end.y - n.y * d4
 			};
-			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)
+			mid = {
+				x: (s.x + e.x) / 2,
+				y: (s.y + e.y) / 2
+			};
+			const bline = [
+				e,
+				mid,
+				s
+			];
+			const ls = utils.makeline(bline[2], fline[0]);
+			const le = utils.makeline(fline[2], bline[0]);
+			return new PolyBezier([
+				ls,
+				new Bezier(fline),
+				le,
+				new Bezier(bline)
 			]);
 		}
-		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);
+		const reduced = this.reduce();
+		const len = reduced.length;
+		const fcurves = [];
+		let bcurves = [];
+		let p;
+		let alen = 0;
+		let tlen = this.length();
+		const graduated = typeof d3 !== "undefined" && typeof d4 !== "undefined";
+		function linearDistanceFunction(s, e, tlen, alen, slen) {
+			return function(v) {
+				const f1 = alen / tlen;
+				const f2 = (alen + slen) / tlen;
+				const d = e - s;
+				return utils.map(v, 0, 1, s + f1 * d, s + f2 * d);
 			};
 		}
-		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;
+		reduced.forEach(function(segment) {
+			const slen = segment.length();
+			if (graduated) {
+				fcurves.push(segment.scale(linearDistanceFunction(d1, d3, tlen, alen, slen)));
+				bcurves.push(segment.scale(linearDistanceFunction(-d2, -d4, tlen, alen, slen)));
+			} else {
+				fcurves.push(segment.scale(d1));
+				bcurves.push(segment.scale(-d2));
+			}
+			alen += slen;
+		});
+		bcurves = bcurves.map(function(s) {
+			p = s.points;
+			if (p[3]) s.points = [
+				p[3],
+				p[2],
+				p[1],
+				p[0]
+			];
+			else s.points = [
+				p[2],
+				p[1],
+				p[0]
+			];
+			return s;
 		}).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);
+		const fs = fcurves[0].points[0];
+		const fe = fcurves[len - 1].points[fcurves[len - 1].points.length - 1];
+		const bs = bcurves[len - 1].points[bcurves[len - 1].points.length - 1];
+		const be = bcurves[0].points[0];
+		const ls = utils.makeline(bs, fs);
+		const le = utils.makeline(fe, be);
+		return new PolyBezier([ls].concat(fcurves).concat([le]).concat(bcurves));
+	}
+	outlineshapes(d1, d2, curveIntersectionThreshold) {
+		d2 = d2 || d1;
+		const outline = this.outline(d1, d2).curves;
+		const shapes = [];
+		for (let i = 1, len = outline.length; i < len / 2; i++) {
+			const shape = utils.makeshape(outline[i], outline[len - i], curveIntersectionThreshold);
+			shape.startcap.virtual = i > 1;
+			shape.endcap.virtual = i < len / 2 - 1;
+			shapes.push(shape);
+		}
+		return shapes;
+	}
+	intersects(curve, curveIntersectionThreshold) {
+		if (!curve) return this.selfintersects(curveIntersectionThreshold);
+		if (curve.p1 && curve.p2) return this.lineIntersects(curve);
+		if (curve instanceof Bezier) curve = curve.reduce();
+		return this.curveintersects(this.reduce(), curve, curveIntersectionThreshold);
+	}
+	lineIntersects(line) {
+		const mx = min(line.p1.x, line.p2.x);
+		const my = min(line.p1.y, line.p2.y);
+		const MX = max(line.p1.x, line.p2.x);
+		const MY = max(line.p1.y, line.p2.y);
+		return utils.roots(this.points, line).filter((t) => {
+			var p = this.get(t);
+			return utils.between(p.x, mx, MX) && utils.between(p.y, my, MY);
 		});
 	}
-	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
+	selfintersects(curveIntersectionThreshold) {
+		const reduced = this.reduce();
+		const len = reduced.length - 2;
+		const results = [];
+		for (let i = 0, result, left, right; i < len; i++) {
+			left = reduced.slice(i, i + 1);
+			right = reduced.slice(i + 2);
+			result = this.curveintersects(left, right, curveIntersectionThreshold);
+			results.push(...result);
+		}
+		return results;
+	}
+	curveintersects(c1, c2, curveIntersectionThreshold) {
+		const pairs = [];
+		c1.forEach(function(l) {
+			c2.forEach(function(r) {
+				if (l.overlaps(r)) pairs.push({
+					left: l,
+					right: r
 				});
 			});
 		});
-		let a = [];
-		return i.forEach(function(e) {
-			let n = g.pairiteration(e.left, e.right, r);
-			n.length > 0 && (a = a.concat(n));
-		}), a;
+		let intersections = [];
+		pairs.forEach(function(pair) {
+			const result = utils.pairiteration(pair.left, pair.right, curveIntersectionThreshold);
+			if (result.length > 0) intersections = intersections.concat(result);
+		});
+		return intersections;
 	}
-	arcs(e) {
-		return e ||= .5, this._iterate(e, []);
+	arcs(errorThreshold) {
+		errorThreshold = errorThreshold || .5;
+		return this._iterate(errorThreshold, []);
 	}
-	_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);
+	_error(pc, np1, s, e) {
+		const q = (e - s) / 4;
+		const c1 = this.get(s + q);
+		const c2 = this.get(e - q);
+		const ref = utils.dist(pc, np1);
+		const d1 = utils.dist(pc, c1);
+		const d2 = utils.dist(pc, c2);
+		return abs(d1 - ref) + abs(d2 - ref);
 	}
-	_iterate(e, n) {
-		let r = 0, i = 1, a;
+	_iterate(errorThreshold, circles) {
+		let t_s = 0;
+		let t_e = 1;
+		let safety;
 		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)
+			safety = 0;
+			t_e = 1;
+			let np1 = this.get(t_s);
+			let np2;
+			let np3;
+			let arc;
+			let prev_arc;
+			let curr_good = false;
+			let prev_good = false;
+			let done;
+			let t_m = t_e;
+			let prev_e = 1;
+			let step = 0;
+			do {
+				prev_good = curr_good;
+				prev_arc = arc;
+				t_m = (t_s + t_e) / 2;
+				step++;
+				np2 = this.get(t_m);
+				np3 = this.get(t_e);
+				arc = utils.getccenter(np1, np2, np3);
+				arc.interval = {
+					start: t_s,
+					end: t_e
+				};
+				curr_good = this._error(arc, np1, t_s, t_e) <= errorThreshold;
+				done = prev_good && !curr_good;
+				if (!done) prev_e = t_e;
+				if (curr_good) {
+					if (t_e >= 1) {
+						arc.interval.end = prev_e = 1;
+						prev_arc = arc;
+						if (t_e > 1) {
+							let d = {
+								x: arc.x + arc.r * cos(arc.e),
+								y: arc.y + arc.r * sin(arc.e)
 							};
-							l.e += g.angle({
-								x: l.x,
-								y: l.y
-							}, e, this.get(1));
+							arc.e += utils.angle({
+								x: arc.x,
+								y: arc.y
+							}, d, 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;
+					t_e = t_e + (t_e - t_s) / 2;
+				} else t_e = t_m;
+			} while (!done && safety++ < 100);
+			if (safety >= 100) break;
+			prev_arc = prev_arc ? prev_arc : arc;
+			circles.push(prev_arc);
+			t_s = prev_e;
+		} while (t_e < 1);
+		return circles;
 	}
 };
 //#endregion
-export { E as t };
+export { Bezier as t };