@loopstack/loopstack-studio 0.25.1 → 0.26.0

package/dist/node_modules/roughjs/bundled/rough.esm.js

@@ -1,200 +1,199 @@
-//#region ../../node_modules/roughjs/bundled/rough.esm.js
-function e(e, t, n) {
-	if (e && e.length) {
-		let [r, i] = t, a = Math.PI / 180 * n, o = Math.cos(a), s = Math.sin(a);
-		for (let t of e) {
-			let [e, n] = t;
-			t[0] = (e - r) * o - (n - i) * s + r, t[1] = (e - r) * s + (n - i) * o + i;
+function t(ee, Me, Ne) {
+	if (ee && ee.length) {
+		let [Pe, Fe] = Me, Ie = Math.PI / 180 * Ne, Le = Math.cos(Ie), Re = Math.sin(Ie);
+		for (let Me of ee) {
+			let [ee, Ne] = Me;
+			Me[0] = (ee - Pe) * Le - (Ne - Fe) * Re + Pe, Me[1] = (ee - Pe) * Re + (Ne - Fe) * Le + Fe;
 		}
 	}
 }
-function t(e, t) {
-	return e[0] === t[0] && e[1] === t[1];
+function e(ee, Me) {
+	return ee[0] === Me[0] && ee[1] === Me[1];
 }
-function n(n, r, i, a = 1) {
-	let o = i, s = Math.max(r, .1), c = n[0] && n[0][0] && typeof n[0][0] == "number" ? [n] : n, l = [0, 0];
-	if (o) for (let t of c) e(t, l, o);
-	let u = function(e, n, r) {
-		let i = [];
-		for (let n of e) {
-			let e = [...n];
-			t(e[0], e[e.length - 1]) || e.push([e[0][0], e[0][1]]), e.length > 2 && i.push(e);
+function s(Ne, Pe, Fe, Ie = 1) {
+	let Le = Fe, Re = Math.max(Pe, .1), ze = Ne[0] && Ne[0][0] && typeof Ne[0][0] == "number" ? [Ne] : Ne, Be = [0, 0];
+	if (Le) for (let Me of ze) t(Me, Be, Le);
+	let Ve = function(ee, Ne, Pe) {
+		let Fe = [];
+		for (let Ne of ee) {
+			let ee = [...Ne];
+			e(ee[0], ee[ee.length - 1]) || ee.push([ee[0][0], ee[0][1]]), ee.length > 2 && Fe.push(ee);
 		}
-		let a = [];
-		n = Math.max(n, .1);
-		let o = [];
-		for (let e of i) for (let t = 0; t < e.length - 1; t++) {
-			let n = e[t], r = e[t + 1];
-			if (n[1] !== r[1]) {
-				let e = Math.min(n[1], r[1]);
-				o.push({
-					ymin: e,
-					ymax: Math.max(n[1], r[1]),
-					x: e === n[1] ? n[0] : r[0],
-					islope: (r[0] - n[0]) / (r[1] - n[1])
+		let Ie = [];
+		Ne = Math.max(Ne, .1);
+		let Le = [];
+		for (let ee of Fe) for (let Me = 0; Me < ee.length - 1; Me++) {
+			let Ne = ee[Me], Pe = ee[Me + 1];
+			if (Ne[1] !== Pe[1]) {
+				let ee = Math.min(Ne[1], Pe[1]);
+				Le.push({
+					ymin: ee,
+					ymax: Math.max(Ne[1], Pe[1]),
+					x: ee === Ne[1] ? Ne[0] : Pe[0],
+					islope: (Pe[0] - Ne[0]) / (Pe[1] - Ne[1])
 				});
 			}
 		}
-		if (o.sort(((e, t) => e.ymin < t.ymin ? -1 : e.ymin > t.ymin ? 1 : e.x < t.x ? -1 : e.x > t.x ? 1 : e.ymax === t.ymax ? 0 : (e.ymax - t.ymax) / Math.abs(e.ymax - t.ymax))), !o.length) return a;
-		let s = [], c = o[0].ymin, l = 0;
-		for (; s.length || o.length;) {
-			if (o.length) {
-				let e = -1;
-				for (let t = 0; t < o.length && !(o[t].ymin > c); t++) e = t;
-				o.splice(0, e + 1).forEach(((e) => {
-					s.push({
-						s: c,
-						edge: e
+		if (Le.sort(((ee, Me) => ee.ymin < Me.ymin ? -1 : ee.ymin > Me.ymin ? 1 : ee.x < Me.x ? -1 : ee.x > Me.x ? 1 : ee.ymax === Me.ymax ? 0 : (ee.ymax - Me.ymax) / Math.abs(ee.ymax - Me.ymax))), !Le.length) return Ie;
+		let Re = [], ze = Le[0].ymin, Be = 0;
+		for (; Re.length || Le.length;) {
+			if (Le.length) {
+				let ee = -1;
+				for (let Me = 0; Me < Le.length && !(Le[Me].ymin > ze); Me++) ee = Me;
+				Le.splice(0, ee + 1).forEach(((ee) => {
+					Re.push({
+						s: ze,
+						edge: ee
 					});
 				}));
 			}
-			if (s = s.filter(((e) => !(e.edge.ymax <= c))), s.sort(((e, t) => e.edge.x === t.edge.x ? 0 : (e.edge.x - t.edge.x) / Math.abs(e.edge.x - t.edge.x))), (r !== 1 || l % n == 0) && s.length > 1) for (let e = 0; e < s.length; e += 2) {
-				let t = e + 1;
-				if (t >= s.length) break;
-				let n = s[e].edge, r = s[t].edge;
-				a.push([[Math.round(n.x), c], [Math.round(r.x), c]]);
+			if (Re = Re.filter(((ee) => !(ee.edge.ymax <= ze))), Re.sort(((ee, Me) => ee.edge.x === Me.edge.x ? 0 : (ee.edge.x - Me.edge.x) / Math.abs(ee.edge.x - Me.edge.x))), (Pe !== 1 || Be % Ne == 0) && Re.length > 1) for (let ee = 0; ee < Re.length; ee += 2) {
+				let Me = ee + 1;
+				if (Me >= Re.length) break;
+				let Ne = Re[ee].edge, Pe = Re[Me].edge;
+				Ie.push([[Math.round(Ne.x), ze], [Math.round(Pe.x), ze]]);
 			}
-			c += r, s.forEach(((e) => {
-				e.edge.x = e.edge.x + r * e.edge.islope;
-			})), l++;
+			ze += Pe, Re.forEach(((ee) => {
+				ee.edge.x = ee.edge.x + Pe * ee.edge.islope;
+			})), Be++;
 		}
-		return a;
-	}(c, s, a);
-	if (o) {
-		for (let t of c) e(t, l, -o);
-		(function(t, n, r) {
-			let i = [];
-			t.forEach(((e) => i.push(...e))), e(i, n, r);
-		})(u, l, -o);
-	}
-	return u;
+		return Ie;
+	}(ze, Re, Ie);
+	if (Le) {
+		for (let Me of ze) t(Me, Be, -Le);
+		(function(Me, Ne, Pe) {
+			let Fe = [];
+			Me.forEach(((ee) => Fe.push(...ee))), t(Fe, Ne, Pe);
+		})(Ve, Be, -Le);
+	}
+	return Ve;
 }
-function r(e, t) {
-	let r = t.hachureAngle + 90, i = t.hachureGap;
-	i < 0 && (i = 4 * t.strokeWidth), i = Math.round(Math.max(i, .1));
-	let a = 1;
-	return t.roughness >= 1 && (t.randomizer?.next() || Math.random()) > .7 && (a = i), n(e, i, r, a || 1);
+function n(ee, Me) {
+	let Pe = Me.hachureAngle + 90, Fe = Me.hachureGap;
+	Fe < 0 && (Fe = 4 * Me.strokeWidth), Fe = Math.round(Math.max(Fe, .1));
+	let Ie = 1;
+	return Me.roughness >= 1 && (Me.randomizer?.next() || Math.random()) > .7 && (Ie = Fe), s(ee, Fe, Pe, Ie || 1);
 }
-var i = class {
-	constructor(e) {
-		this.helper = e;
+var o = class {
+	constructor(ee) {
+		this.helper = ee;
 	}
-	fillPolygons(e, t) {
-		return this._fillPolygons(e, t);
+	fillPolygons(ee, Me) {
+		return this._fillPolygons(ee, Me);
 	}
-	_fillPolygons(e, t) {
-		let n = r(e, t);
+	_fillPolygons(ee, Me) {
+		let Ne = n(ee, Me);
 		return {
 			type: "fillSketch",
-			ops: this.renderLines(n, t)
+			ops: this.renderLines(Ne, Me)
 		};
 	}
-	renderLines(e, t) {
-		let n = [];
-		for (let r of e) n.push(...this.helper.doubleLineOps(r[0][0], r[0][1], r[1][0], r[1][1], t));
-		return n;
+	renderLines(ee, Me) {
+		let Ne = [];
+		for (let Pe of ee) Ne.push(...this.helper.doubleLineOps(Pe[0][0], Pe[0][1], Pe[1][0], Pe[1][1], Me));
+		return Ne;
 	}
 };
-function a(e) {
-	let t = e[0], n = e[1];
-	return Math.sqrt((t[0] - n[0]) ** 2 + (t[1] - n[1]) ** 2);
+function a(ee) {
+	let Me = ee[0], Ne = ee[1];
+	return Math.sqrt((Me[0] - Ne[0]) ** 2 + (Me[1] - Ne[1]) ** 2);
 }
-var o = class extends i {
-	fillPolygons(e, t) {
-		let n = t.hachureGap;
-		n < 0 && (n = 4 * t.strokeWidth), n = Math.max(n, .1);
-		let i = r(e, Object.assign({}, t, { hachureGap: n })), o = Math.PI / 180 * t.hachureAngle, s = [], c = .5 * n * Math.cos(o), l = .5 * n * Math.sin(o);
-		for (let [e, t] of i) a([e, t]) && s.push([[e[0] - c, e[1] + l], [...t]], [[e[0] + c, e[1] - l], [...t]]);
+var h = class extends o {
+	fillPolygons(ee, Me) {
+		let Ne = Me.hachureGap;
+		Ne < 0 && (Ne = 4 * Me.strokeWidth), Ne = Math.max(Ne, .1);
+		let Fe = n(ee, Object.assign({}, Me, { hachureGap: Ne })), Le = Math.PI / 180 * Me.hachureAngle, Re = [], ze = .5 * Ne * Math.cos(Le), Be = .5 * Ne * Math.sin(Le);
+		for (let [ee, Me] of Fe) a([ee, Me]) && Re.push([[ee[0] - ze, ee[1] + Be], [...Me]], [[ee[0] + ze, ee[1] - Be], [...Me]]);
 		return {
 			type: "fillSketch",
-			ops: this.renderLines(s, t)
+			ops: this.renderLines(Re, Me)
 		};
 	}
-}, s = class extends i {
-	fillPolygons(e, t) {
-		let n = this._fillPolygons(e, t), r = Object.assign({}, t, { hachureAngle: t.hachureAngle + 90 }), i = this._fillPolygons(e, r);
-		return n.ops = n.ops.concat(i.ops), n;
-	}
-}, c = class {
-	constructor(e) {
-		this.helper = e;
-	}
-	fillPolygons(e, t) {
-		let n = r(e, t = Object.assign({}, t, { hachureAngle: 0 }));
-		return this.dotsOnLines(n, t);
-	}
-	dotsOnLines(e, t) {
-		let n = [], r = t.hachureGap;
-		r < 0 && (r = 4 * t.strokeWidth), r = Math.max(r, .1);
-		let i = t.fillWeight;
-		i < 0 && (i = t.strokeWidth / 2);
-		let o = r / 4;
-		for (let s of e) {
-			let e = a(s), c = e / r, l = Math.ceil(c) - 1, u = e - l * r, d = (s[0][0] + s[1][0]) / 2 - r / 4, f = Math.min(s[0][1], s[1][1]);
-			for (let e = 0; e < l; e++) {
-				let a = f + u + e * r, s = d - o + 2 * Math.random() * o, c = a - o + 2 * Math.random() * o, l = this.helper.ellipse(s, c, i, i, t);
-				n.push(...l.ops);
+}, r = class extends o {
+	fillPolygons(ee, Me) {
+		let Ne = this._fillPolygons(ee, Me), Pe = Object.assign({}, Me, { hachureAngle: Me.hachureAngle + 90 }), Fe = this._fillPolygons(ee, Pe);
+		return Ne.ops = Ne.ops.concat(Fe.ops), Ne;
+	}
+}, i = class {
+	constructor(ee) {
+		this.helper = ee;
+	}
+	fillPolygons(ee, Me) {
+		let Ne = n(ee, Me = Object.assign({}, Me, { hachureAngle: 0 }));
+		return this.dotsOnLines(Ne, Me);
+	}
+	dotsOnLines(ee, Me) {
+		let Ne = [], Pe = Me.hachureGap;
+		Pe < 0 && (Pe = 4 * Me.strokeWidth), Pe = Math.max(Pe, .1);
+		let Fe = Me.fillWeight;
+		Fe < 0 && (Fe = Me.strokeWidth / 2);
+		let Le = Pe / 4;
+		for (let Re of ee) {
+			let ee = a(Re), ze = ee / Pe, Be = Math.ceil(ze) - 1, Ve = ee - Be * Pe, He = (Re[0][0] + Re[1][0]) / 2 - Pe / 4, Ue = Math.min(Re[0][1], Re[1][1]);
+			for (let ee = 0; ee < Be; ee++) {
+				let Ie = Ue + Ve + ee * Pe, Re = He - Le + 2 * Math.random() * Le, ze = Ie - Le + 2 * Math.random() * Le, Be = this.helper.ellipse(Re, ze, Fe, Fe, Me);
+				Ne.push(...Be.ops);
 			}
 		}
 		return {
 			type: "fillSketch",
-			ops: n
+			ops: Ne
 		};
 	}
-}, l = class {
-	constructor(e) {
-		this.helper = e;
+}, c = class {
+	constructor(ee) {
+		this.helper = ee;
 	}
-	fillPolygons(e, t) {
-		let n = r(e, t);
+	fillPolygons(ee, Me) {
+		let Ne = n(ee, Me);
 		return {
 			type: "fillSketch",
-			ops: this.dashedLine(n, t)
+			ops: this.dashedLine(Ne, Me)
 		};
 	}
-	dashedLine(e, t) {
-		let n = t.dashOffset < 0 ? t.hachureGap < 0 ? 4 * t.strokeWidth : t.hachureGap : t.dashOffset, r = t.dashGap < 0 ? t.hachureGap < 0 ? 4 * t.strokeWidth : t.hachureGap : t.dashGap, i = [];
-		return e.forEach(((e) => {
-			let o = a(e), s = Math.floor(o / (n + r)), c = (o + r - s * (n + r)) / 2, l = e[0], u = e[1];
-			l[0] > u[0] && (l = e[1], u = e[0]);
-			let d = Math.atan((u[1] - l[1]) / (u[0] - l[0]));
-			for (let e = 0; e < s; e++) {
-				let a = e * (n + r), o = a + n, s = [l[0] + a * Math.cos(d) + c * Math.cos(d), l[1] + a * Math.sin(d) + c * Math.sin(d)], u = [l[0] + o * Math.cos(d) + c * Math.cos(d), l[1] + o * Math.sin(d) + c * Math.sin(d)];
-				i.push(...this.helper.doubleLineOps(s[0], s[1], u[0], u[1], t));
+	dashedLine(ee, Me) {
+		let Ne = Me.dashOffset < 0 ? Me.hachureGap < 0 ? 4 * Me.strokeWidth : Me.hachureGap : Me.dashOffset, Pe = Me.dashGap < 0 ? Me.hachureGap < 0 ? 4 * Me.strokeWidth : Me.hachureGap : Me.dashGap, Fe = [];
+		return ee.forEach(((ee) => {
+			let Le = a(ee), Re = Math.floor(Le / (Ne + Pe)), ze = (Le + Pe - Re * (Ne + Pe)) / 2, Be = ee[0], Ve = ee[1];
+			Be[0] > Ve[0] && (Be = ee[1], Ve = ee[0]);
+			let He = Math.atan((Ve[1] - Be[1]) / (Ve[0] - Be[0]));
+			for (let ee = 0; ee < Re; ee++) {
+				let Ie = ee * (Ne + Pe), Le = Ie + Ne, Re = [Be[0] + Ie * Math.cos(He) + ze * Math.cos(He), Be[1] + Ie * Math.sin(He) + ze * Math.sin(He)], Ve = [Be[0] + Le * Math.cos(He) + ze * Math.cos(He), Be[1] + Le * Math.sin(He) + ze * Math.sin(He)];
+				Fe.push(...this.helper.doubleLineOps(Re[0], Re[1], Ve[0], Ve[1], Me));
 			}
-		})), i;
+		})), Fe;
 	}
-}, u = class {
-	constructor(e) {
-		this.helper = e;
+}, l = class {
+	constructor(ee) {
+		this.helper = ee;
 	}
-	fillPolygons(e, t) {
-		let n = t.hachureGap < 0 ? 4 * t.strokeWidth : t.hachureGap, i = t.zigzagOffset < 0 ? n : t.zigzagOffset, a = r(e, t = Object.assign({}, t, { hachureGap: n + i }));
+	fillPolygons(ee, Me) {
+		let Ne = Me.hachureGap < 0 ? 4 * Me.strokeWidth : Me.hachureGap, Fe = Me.zigzagOffset < 0 ? Ne : Me.zigzagOffset, Ie = n(ee, Me = Object.assign({}, Me, { hachureGap: Ne + Fe }));
 		return {
 			type: "fillSketch",
-			ops: this.zigzagLines(a, i, t)
+			ops: this.zigzagLines(Ie, Fe, Me)
 		};
 	}
-	zigzagLines(e, t, n) {
-		let r = [];
-		return e.forEach(((e) => {
-			let i = a(e), o = Math.round(i / (2 * t)), s = e[0], c = e[1];
-			s[0] > c[0] && (s = e[1], c = e[0]);
-			let l = Math.atan((c[1] - s[1]) / (c[0] - s[0]));
-			for (let e = 0; e < o; e++) {
-				let i = 2 * e * t, a = 2 * (e + 1) * t, o = Math.sqrt(2 * t ** 2), c = [s[0] + i * Math.cos(l), s[1] + i * Math.sin(l)], u = [s[0] + a * Math.cos(l), s[1] + a * Math.sin(l)], d = [c[0] + o * Math.cos(l + Math.PI / 4), c[1] + o * Math.sin(l + Math.PI / 4)];
-				r.push(...this.helper.doubleLineOps(c[0], c[1], d[0], d[1], n), ...this.helper.doubleLineOps(d[0], d[1], u[0], u[1], n));
+	zigzagLines(ee, Me, Ne) {
+		let Pe = [];
+		return ee.forEach(((ee) => {
+			let Fe = a(ee), Le = Math.round(Fe / (2 * Me)), Re = ee[0], ze = ee[1];
+			Re[0] > ze[0] && (Re = ee[1], ze = ee[0]);
+			let Be = Math.atan((ze[1] - Re[1]) / (ze[0] - Re[0]));
+			for (let ee = 0; ee < Le; ee++) {
+				let Fe = 2 * ee * Me, Ie = 2 * (ee + 1) * Me, Le = Math.sqrt(2 * Me ** 2), ze = [Re[0] + Fe * Math.cos(Be), Re[1] + Fe * Math.sin(Be)], Ve = [Re[0] + Ie * Math.cos(Be), Re[1] + Ie * Math.sin(Be)], He = [ze[0] + Le * Math.cos(Be + Math.PI / 4), ze[1] + Le * Math.sin(Be + Math.PI / 4)];
+				Pe.push(...this.helper.doubleLineOps(ze[0], ze[1], He[0], He[1], Ne), ...this.helper.doubleLineOps(He[0], He[1], Ve[0], Ve[1], Ne));
 			}
-		})), r;
+		})), Pe;
 	}
-}, d = {}, f = class {
-	constructor(e) {
-		this.seed = e;
+}, u = {}, p = class {
+	constructor(ee) {
+		this.seed = ee;
 	}
 	next() {
 		return this.seed ? (2 ** 31 - 1 & (this.seed = Math.imul(48271, this.seed))) / 2 ** 31 : Math.random();
 	}
-}, p = 0, m = 1, h = 2, g = {
+}, f = 0, d = 1, g = 2, M = {
 	A: 7,
 	a: 7,
 	C: 6,
@@ -216,404 +215,404 @@ var o = class extends i {
 	Z: 0,
 	z: 0
 };
-function _(e, t) {
-	return e.type === t;
+function k(ee, Me) {
+	return ee.type === Me;
 }
-function v(e) {
-	let t = [], n = function(e) {
-		let t = [];
-		for (; e !== "";) if (e.match(/^([ \t\r\n,]+)/)) e = e.substr(RegExp.$1.length);
-		else if (e.match(/^([aAcChHlLmMqQsStTvVzZ])/)) t[t.length] = {
-			type: p,
+function b(ee) {
+	let Me = [], Ne = function(ee) {
+		let Me = [];
+		for (; ee !== "";) if (ee.match(/^([ \t\r\n,]+)/)) ee = ee.substr(RegExp.$1.length);
+		else if (ee.match(/^([aAcChHlLmMqQsStTvVzZ])/)) Me[Me.length] = {
+			type: f,
 			text: RegExp.$1
-		}, e = e.substr(RegExp.$1.length);
+		}, ee = ee.substr(RegExp.$1.length);
 		else {
-			if (!e.match(/^(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)/)) return [];
-			t[t.length] = {
-				type: m,
+			if (!ee.match(/^(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)/)) return [];
+			Me[Me.length] = {
+				type: d,
 				text: `${parseFloat(RegExp.$1)}`
-			}, e = e.substr(RegExp.$1.length);
+			}, ee = ee.substr(RegExp.$1.length);
 		}
-		return t[t.length] = {
-			type: h,
+		return Me[Me.length] = {
+			type: g,
 			text: ""
-		}, t;
-	}(e), r = "BOD", i = 0, a = n[i];
-	for (; !_(a, h);) {
-		let o = 0, s = [];
-		if (r === "BOD") {
-			if (a.text !== "M" && a.text !== "m") return v("M0,0" + e);
-			i++, o = g[a.text], r = a.text;
-		} else _(a, m) ? o = g[r] : (i++, o = g[a.text], r = a.text);
-		if (!(i + o < n.length)) throw Error("Path data ended short");
-		for (let e = i; e < i + o; e++) {
-			let t = n[e];
-			if (!_(t, m)) throw Error("Param not a number: " + r + "," + t.text);
-			s[s.length] = +t.text;
+		}, Me;
+	}(ee), Pe = "BOD", Fe = 0, Ie = Ne[Fe];
+	for (; !k(Ie, g);) {
+		let Le = 0, Re = [];
+		if (Pe === "BOD") {
+			if (Ie.text !== "M" && Ie.text !== "m") return b("M0,0" + ee);
+			Fe++, Le = M[Ie.text], Pe = Ie.text;
+		} else k(Ie, d) ? Le = M[Pe] : (Fe++, Le = M[Ie.text], Pe = Ie.text);
+		if (!(Fe + Le < Ne.length)) throw Error("Path data ended short");
+		for (let ee = Fe; ee < Fe + Le; ee++) {
+			let Me = Ne[ee];
+			if (!k(Me, d)) throw Error("Param not a number: " + Pe + "," + Me.text);
+			Re[Re.length] = +Me.text;
 		}
-		if (typeof g[r] != "number") throw Error("Bad segment: " + r);
+		if (typeof M[Pe] != "number") throw Error("Bad segment: " + Pe);
 		{
-			let e = {
-				key: r,
-				data: s
+			let ee = {
+				key: Pe,
+				data: Re
 			};
-			t.push(e), i += o, a = n[i], r === "M" && (r = "L"), r === "m" && (r = "l");
+			Me.push(ee), Fe += Le, Ie = Ne[Fe], Pe === "M" && (Pe = "L"), Pe === "m" && (Pe = "l");
 		}
 	}
-	return t;
+	return Me;
 }
-function y(e) {
-	let t = 0, n = 0, r = 0, i = 0, a = [];
-	for (let { key: o, data: s } of e) switch (o) {
+function y(ee) {
+	let Me = 0, Ne = 0, Pe = 0, Fe = 0, Ie = [];
+	for (let { key: Le, data: Re } of ee) switch (Le) {
 		case "M":
-			a.push({
+			Ie.push({
 				key: "M",
-				data: [...s]
-			}), [t, n] = s, [r, i] = s;
+				data: [...Re]
+			}), [Me, Ne] = Re, [Pe, Fe] = Re;
 			break;
 		case "m":
-			t += s[0], n += s[1], a.push({
+			Me += Re[0], Ne += Re[1], Ie.push({
 				key: "M",
-				data: [t, n]
-			}), r = t, i = n;
+				data: [Me, Ne]
+			}), Pe = Me, Fe = Ne;
 			break;
 		case "L":
-			a.push({
+			Ie.push({
 				key: "L",
-				data: [...s]
-			}), [t, n] = s;
+				data: [...Re]
+			}), [Me, Ne] = Re;
 			break;
 		case "l":
-			t += s[0], n += s[1], a.push({
+			Me += Re[0], Ne += Re[1], Ie.push({
 				key: "L",
-				data: [t, n]
+				data: [Me, Ne]
 			});
 			break;
 		case "C":
-			a.push({
+			Ie.push({
 				key: "C",
-				data: [...s]
-			}), t = s[4], n = s[5];
+				data: [...Re]
+			}), Me = Re[4], Ne = Re[5];
 			break;
 		case "c": {
-			let e = s.map(((e, r) => r % 2 ? e + n : e + t));
-			a.push({
+			let ee = Re.map(((ee, Pe) => Pe % 2 ? ee + Ne : ee + Me));
+			Ie.push({
 				key: "C",
-				data: e
-			}), t = e[4], n = e[5];
+				data: ee
+			}), Me = ee[4], Ne = ee[5];
 			break;
 		}
 		case "Q":
-			a.push({
+			Ie.push({
 				key: "Q",
-				data: [...s]
-			}), t = s[2], n = s[3];
+				data: [...Re]
+			}), Me = Re[2], Ne = Re[3];
 			break;
 		case "q": {
-			let e = s.map(((e, r) => r % 2 ? e + n : e + t));
-			a.push({
+			let ee = Re.map(((ee, Pe) => Pe % 2 ? ee + Ne : ee + Me));
+			Ie.push({
 				key: "Q",
-				data: e
-			}), t = e[2], n = e[3];
+				data: ee
+			}), Me = ee[2], Ne = ee[3];
 			break;
 		}
 		case "A":
-			a.push({
+			Ie.push({
 				key: "A",
-				data: [...s]
-			}), t = s[5], n = s[6];
+				data: [...Re]
+			}), Me = Re[5], Ne = Re[6];
 			break;
 		case "a":
-			t += s[5], n += s[6], a.push({
+			Me += Re[5], Ne += Re[6], Ie.push({
 				key: "A",
 				data: [
-					s[0],
-					s[1],
-					s[2],
-					s[3],
-					s[4],
-					t,
-					n
+					Re[0],
+					Re[1],
+					Re[2],
+					Re[3],
+					Re[4],
+					Me,
+					Ne
 				]
 			});
 			break;
 		case "H":
-			a.push({
+			Ie.push({
 				key: "H",
-				data: [...s]
-			}), t = s[0];
+				data: [...Re]
+			}), Me = Re[0];
 			break;
 		case "h":
-			t += s[0], a.push({
+			Me += Re[0], Ie.push({
 				key: "H",
-				data: [t]
+				data: [Me]
 			});
 			break;
 		case "V":
-			a.push({
+			Ie.push({
 				key: "V",
-				data: [...s]
-			}), n = s[0];
+				data: [...Re]
+			}), Ne = Re[0];
 			break;
 		case "v":
-			n += s[0], a.push({
+			Ne += Re[0], Ie.push({
 				key: "V",
-				data: [n]
+				data: [Ne]
 			});
 			break;
 		case "S":
-			a.push({
+			Ie.push({
 				key: "S",
-				data: [...s]
-			}), t = s[2], n = s[3];
+				data: [...Re]
+			}), Me = Re[2], Ne = Re[3];
 			break;
 		case "s": {
-			let e = s.map(((e, r) => r % 2 ? e + n : e + t));
-			a.push({
+			let ee = Re.map(((ee, Pe) => Pe % 2 ? ee + Ne : ee + Me));
+			Ie.push({
 				key: "S",
-				data: e
-			}), t = e[2], n = e[3];
+				data: ee
+			}), Me = ee[2], Ne = ee[3];
 			break;
 		}
 		case "T":
-			a.push({
+			Ie.push({
 				key: "T",
-				data: [...s]
-			}), t = s[0], n = s[1];
+				data: [...Re]
+			}), Me = Re[0], Ne = Re[1];
 			break;
 		case "t":
-			t += s[0], n += s[1], a.push({
+			Me += Re[0], Ne += Re[1], Ie.push({
 				key: "T",
-				data: [t, n]
+				data: [Me, Ne]
 			});
 			break;
 		case "Z":
-		case "z": a.push({
+		case "z": Ie.push({
 			key: "Z",
 			data: []
-		}), t = r, n = i;
+		}), Me = Pe, Ne = Fe;
 	}
-	return a;
+	return Ie;
 }
-function b(e) {
-	let t = [], n = "", r = 0, i = 0, a = 0, o = 0, s = 0, c = 0;
-	for (let { key: l, data: u } of e) {
-		switch (l) {
+function m(ee) {
+	let Me = [], Ne = "", Pe = 0, Fe = 0, Ie = 0, Le = 0, Re = 0, ze = 0;
+	for (let { key: Be, data: Ve } of ee) {
+		switch (Be) {
 			case "M":
-				t.push({
+				Me.push({
 					key: "M",
-					data: [...u]
-				}), [r, i] = u, [a, o] = u;
+					data: [...Ve]
+				}), [Pe, Fe] = Ve, [Ie, Le] = Ve;
 				break;
 			case "C":
-				t.push({
+				Me.push({
 					key: "C",
-					data: [...u]
-				}), r = u[4], i = u[5], s = u[2], c = u[3];
+					data: [...Ve]
+				}), Pe = Ve[4], Fe = Ve[5], Re = Ve[2], ze = Ve[3];
 				break;
 			case "L":
-				t.push({
+				Me.push({
 					key: "L",
-					data: [...u]
-				}), [r, i] = u;
+					data: [...Ve]
+				}), [Pe, Fe] = Ve;
 				break;
 			case "H":
-				r = u[0], t.push({
+				Pe = Ve[0], Me.push({
 					key: "L",
-					data: [r, i]
+					data: [Pe, Fe]
 				});
 				break;
 			case "V":
-				i = u[0], t.push({
+				Fe = Ve[0], Me.push({
 					key: "L",
-					data: [r, i]
+					data: [Pe, Fe]
 				});
 				break;
 			case "S": {
-				let e = 0, a = 0;
-				n === "C" || n === "S" ? (e = r + (r - s), a = i + (i - c)) : (e = r, a = i), t.push({
+				let ee = 0, Ie = 0;
+				Ne === "C" || Ne === "S" ? (ee = Pe + (Pe - Re), Ie = Fe + (Fe - ze)) : (ee = Pe, Ie = Fe), Me.push({
 					key: "C",
 					data: [
-						e,
-						a,
-						...u
+						ee,
+						Ie,
+						...Ve
 					]
-				}), s = u[0], c = u[1], r = u[2], i = u[3];
+				}), Re = Ve[0], ze = Ve[1], Pe = Ve[2], Fe = Ve[3];
 				break;
 			}
 			case "T": {
-				let [e, a] = u, o = 0, l = 0;
-				n === "Q" || n === "T" ? (o = r + (r - s), l = i + (i - c)) : (o = r, l = i);
-				let d = r + 2 * (o - r) / 3, f = i + 2 * (l - i) / 3, p = e + 2 * (o - e) / 3, m = a + 2 * (l - a) / 3;
-				t.push({
+				let [ee, Ie] = Ve, Le = 0, Be = 0;
+				Ne === "Q" || Ne === "T" ? (Le = Pe + (Pe - Re), Be = Fe + (Fe - ze)) : (Le = Pe, Be = Fe);
+				let He = Pe + 2 * (Le - Pe) / 3, Ue = Fe + 2 * (Be - Fe) / 3, We = ee + 2 * (Le - ee) / 3, Ge = Ie + 2 * (Be - Ie) / 3;
+				Me.push({
 					key: "C",
 					data: [
-						d,
-						f,
-						p,
-						m,
-						e,
-						a
+						He,
+						Ue,
+						We,
+						Ge,
+						ee,
+						Ie
 					]
-				}), s = o, c = l, r = e, i = a;
+				}), Re = Le, ze = Be, Pe = ee, Fe = Ie;
 				break;
 			}
 			case "Q": {
-				let [e, n, a, o] = u, l = r + 2 * (e - r) / 3, d = i + 2 * (n - i) / 3, f = a + 2 * (e - a) / 3, p = o + 2 * (n - o) / 3;
-				t.push({
+				let [ee, Ne, Ie, Le] = Ve, Be = Pe + 2 * (ee - Pe) / 3, He = Fe + 2 * (Ne - Fe) / 3, Ue = Ie + 2 * (ee - Ie) / 3, We = Le + 2 * (Ne - Le) / 3;
+				Me.push({
 					key: "C",
 					data: [
-						l,
-						d,
-						f,
-						p,
-						a,
-						o
+						Be,
+						He,
+						Ue,
+						We,
+						Ie,
+						Le
 					]
-				}), s = e, c = n, r = a, i = o;
+				}), Re = ee, ze = Ne, Pe = Ie, Fe = Le;
 				break;
 			}
 			case "A": {
-				let e = Math.abs(u[0]), n = Math.abs(u[1]), a = u[2], o = u[3], s = u[4], c = u[5], l = u[6];
-				e === 0 || n === 0 ? (t.push({
+				let ee = Math.abs(Ve[0]), Ne = Math.abs(Ve[1]), Ie = Ve[2], Le = Ve[3], Re = Ve[4], ze = Ve[5], Be = Ve[6];
+				ee === 0 || Ne === 0 ? (Me.push({
 					key: "C",
 					data: [
-						r,
-						i,
-						c,
-						l,
-						c,
-						l
+						Pe,
+						Fe,
+						ze,
+						Be,
+						ze,
+						Be
 					]
-				}), r = c, i = l) : (r !== c || i !== l) && (S(r, i, c, l, e, n, a, o, s).forEach((function(e) {
-					t.push({
+				}), Pe = ze, Fe = Be) : (Pe !== ze || Fe !== Be) && (x(Pe, Fe, ze, Be, ee, Ne, Ie, Le, Re).forEach((function(ee) {
+					Me.push({
 						key: "C",
-						data: e
+						data: ee
 					});
-				})), r = c, i = l);
+				})), Pe = ze, Fe = Be);
 				break;
 			}
-			case "Z": t.push({
+			case "Z": Me.push({
 				key: "Z",
 				data: []
-			}), r = a, i = o;
+			}), Pe = Ie, Fe = Le;
 		}
-		n = l;
+		Ne = Be;
 	}
-	return t;
+	return Me;
 }
-function x(e, t, n) {
-	return [e * Math.cos(n) - t * Math.sin(n), e * Math.sin(n) + t * Math.cos(n)];
+function w(ee, Me, Ne) {
+	return [ee * Math.cos(Ne) - Me * Math.sin(Ne), ee * Math.sin(Ne) + Me * Math.cos(Ne)];
 }
-function S(e, t, n, r, i, a, o, s, c, l) {
-	let u = (d = o, Math.PI * d / 180);
-	var d;
-	let f = [], p = 0, m = 0, h = 0, g = 0;
-	if (l) [p, m, h, g] = l;
+function x(ee, Me, Ne, Pe, Fe, Ie, Le, Re, ze, Be) {
+	let Ve = (He = Le, Math.PI * He / 180);
+	var He;
+	let Ue = [], We = 0, Ge = 0, Ke = 0, qe = 0;
+	if (Be) [We, Ge, Ke, qe] = Be;
 	else {
-		[e, t] = x(e, t, -u), [n, r] = x(n, r, -u);
-		let o = (e - n) / 2, l = (t - r) / 2, d = o * o / (i * i) + l * l / (a * a);
-		d > 1 && (d = Math.sqrt(d), i *= d, a *= d);
-		let f = i * i, _ = a * a, v = f * _ - f * l * l - _ * o * o, y = f * l * l + _ * o * o, b = (s === c ? -1 : 1) * Math.sqrt(Math.abs(v / y));
-		h = b * i * l / a + (e + n) / 2, g = b * -a * o / i + (t + r) / 2, p = Math.asin(parseFloat(((t - g) / a).toFixed(9))), m = Math.asin(parseFloat(((r - g) / a).toFixed(9))), e < h && (p = Math.PI - p), n < h && (m = Math.PI - m), p < 0 && (p = 2 * Math.PI + p), m < 0 && (m = 2 * Math.PI + m), c && p > m && (p -= 2 * Math.PI), !c && m > p && (m -= 2 * Math.PI);
-	}
-	let _ = m - p;
-	if (Math.abs(_) > 120 * Math.PI / 180) {
-		let e = m, t = n, s = r;
-		m = c && m > p ? p + 120 * Math.PI / 180 * 1 : p + 120 * Math.PI / 180 * -1, f = S(n = h + i * Math.cos(m), r = g + a * Math.sin(m), t, s, i, a, o, 0, c, [
-			m,
-			e,
-			h,
-			g
+		[ee, Me] = w(ee, Me, -Ve), [Ne, Pe] = w(Ne, Pe, -Ve);
+		let Le = (ee - Ne) / 2, Be = (Me - Pe) / 2, He = Le * Le / (Fe * Fe) + Be * Be / (Ie * Ie);
+		He > 1 && (He = Math.sqrt(He), Fe *= He, Ie *= He);
+		let Ue = Fe * Fe, Je = Ie * Ie, Ye = Ue * Je - Ue * Be * Be - Je * Le * Le, Xe = Ue * Be * Be + Je * Le * Le, Ze = (Re === ze ? -1 : 1) * Math.sqrt(Math.abs(Ye / Xe));
+		Ke = Ze * Fe * Be / Ie + (ee + Ne) / 2, qe = Ze * -Ie * Le / Fe + (Me + Pe) / 2, We = Math.asin(parseFloat(((Me - qe) / Ie).toFixed(9))), Ge = Math.asin(parseFloat(((Pe - qe) / Ie).toFixed(9))), ee < Ke && (We = Math.PI - We), Ne < Ke && (Ge = Math.PI - Ge), We < 0 && (We = 2 * Math.PI + We), Ge < 0 && (Ge = 2 * Math.PI + Ge), ze && We > Ge && (We -= 2 * Math.PI), !ze && Ge > We && (Ge -= 2 * Math.PI);
+	}
+	let Je = Ge - We;
+	if (Math.abs(Je) > 120 * Math.PI / 180) {
+		let ee = Ge, Me = Ne, Re = Pe;
+		Ge = ze && Ge > We ? We + 120 * Math.PI / 180 * 1 : We + 120 * Math.PI / 180 * -1, Ue = x(Ne = Ke + Fe * Math.cos(Ge), Pe = qe + Ie * Math.sin(Ge), Me, Re, Fe, Ie, Le, 0, ze, [
+			Ge,
+			ee,
+			Ke,
+			qe
 		]);
 	}
-	_ = m - p;
-	let v = Math.cos(p), y = Math.sin(p), b = Math.cos(m), C = Math.sin(m), w = Math.tan(_ / 4), T = 4 / 3 * i * w, E = 4 / 3 * a * w, D = [e, t], O = [e + T * y, t - E * v], k = [n + T * C, r - E * b], A = [n, r];
-	if (O[0] = 2 * D[0] - O[0], O[1] = 2 * D[1] - O[1], l) return [
-		O,
-		k,
-		A
-	].concat(f);
+	Je = Ge - We;
+	let Ye = Math.cos(We), Xe = Math.sin(We), Ze = Math.cos(Ge), Qe = Math.sin(Ge), $e = Math.tan(Je / 4), rt = 4 / 3 * Fe * $e, it = 4 / 3 * Ie * $e, ct = [ee, Me], lt = [ee + rt * Xe, Me - it * Ye], ut = [Ne + rt * Qe, Pe - it * Ze], dt = [Ne, Pe];
+	if (lt[0] = 2 * ct[0] - lt[0], lt[1] = 2 * ct[1] - lt[1], Be) return [
+		lt,
+		ut,
+		dt
+	].concat(Ue);
 	{
-		f = [
-			O,
-			k,
-			A
-		].concat(f);
-		let e = [];
-		for (let t = 0; t < f.length; t += 3) {
-			let n = x(f[t][0], f[t][1], u), r = x(f[t + 1][0], f[t + 1][1], u), i = x(f[t + 2][0], f[t + 2][1], u);
-			e.push([
-				n[0],
-				n[1],
-				r[0],
-				r[1],
-				i[0],
-				i[1]
+		Ue = [
+			lt,
+			ut,
+			dt
+		].concat(Ue);
+		let ee = [];
+		for (let Me = 0; Me < Ue.length; Me += 3) {
+			let Ne = w(Ue[Me][0], Ue[Me][1], Ve), Pe = w(Ue[Me + 1][0], Ue[Me + 1][1], Ve), Fe = w(Ue[Me + 2][0], Ue[Me + 2][1], Ve);
+			ee.push([
+				Ne[0],
+				Ne[1],
+				Pe[0],
+				Pe[1],
+				Fe[0],
+				Fe[1]
 			]);
 		}
-		return e;
+		return ee;
 	}
 }
-var C = {
-	randOffset: function(e, t) {
-		return L(e, t);
+var P = {
+	randOffset: function(ee, Me) {
+		return G(ee, Me);
 	},
-	randOffsetWithRange: function(e, t, n) {
-		return I(e, t, n);
+	randOffsetWithRange: function(ee, Me, Ne) {
+		return E(ee, Me, Ne);
 	},
-	ellipse: function(e, t, n, r, i) {
-		return k(e, t, i, O(n, r, i)).opset;
+	ellipse: function(ee, Me, Ne, Pe, Fe) {
+		return D(ee, Me, Fe, T(Ne, Pe, Fe)).opset;
 	},
-	doubleLineOps: function(e, t, n, r, i) {
-		return R(e, t, n, r, i, !0);
+	doubleLineOps: function(ee, Me, Ne, Pe, Fe) {
+		return $(ee, Me, Ne, Pe, Fe, !0);
 	}
 };
-function w(e, t, n, r, i) {
+function v(ee, Me, Ne, Pe, Fe) {
 	return {
 		type: "path",
-		ops: R(e, t, n, r, i)
+		ops: $(ee, Me, Ne, Pe, Fe)
 	};
 }
-function T(e, t, n) {
-	let r = (e || []).length;
-	if (r > 2) {
-		let i = [];
-		for (let t = 0; t < r - 1; t++) i.push(...R(e[t][0], e[t][1], e[t + 1][0], e[t + 1][1], n));
-		return t && i.push(...R(e[r - 1][0], e[r - 1][1], e[0][0], e[0][1], n)), {
+function S(ee, Me, Ne) {
+	let Pe = (ee || []).length;
+	if (Pe > 2) {
+		let Fe = [];
+		for (let Me = 0; Me < Pe - 1; Me++) Fe.push(...$(ee[Me][0], ee[Me][1], ee[Me + 1][0], ee[Me + 1][1], Ne));
+		return Me && Fe.push(...$(ee[Pe - 1][0], ee[Pe - 1][1], ee[0][0], ee[0][1], Ne)), {
 			type: "path",
-			ops: i
+			ops: Fe
 		};
 	}
-	return r === 2 ? w(e[0][0], e[0][1], e[1][0], e[1][1], n) : {
+	return Pe === 2 ? v(ee[0][0], ee[0][1], ee[1][0], ee[1][1], Ne) : {
 		type: "path",
 		ops: []
 	};
 }
-function E(e, t, n, r, i) {
-	return function(e, t) {
-		return T(e, !0, t);
+function O(ee, Me, Ne, Pe, Fe) {
+	return function(ee, Me) {
+		return S(ee, !0, Me);
 	}([
-		[e, t],
-		[e + n, t],
-		[e + n, t + r],
-		[e, t + r]
-	], i);
+		[ee, Me],
+		[ee + Ne, Me],
+		[ee + Ne, Me + Pe],
+		[ee, Me + Pe]
+	], Fe);
 }
-function D(e, t) {
-	if (e.length) {
-		let n = typeof e[0][0] == "number" ? [e] : e, r = B(n[0], 1 * (1 + .2 * t.roughness), t), i = t.disableMultiStroke ? [] : B(n[0], 1.5 * (1 + .22 * t.roughness), P(t));
-		for (let e = 1; e < n.length; e++) {
-			let a = n[e];
-			if (a.length) {
-				let e = B(a, 1 * (1 + .2 * t.roughness), t), n = t.disableMultiStroke ? [] : B(a, 1.5 * (1 + .22 * t.roughness), P(t));
-				for (let t of e) t.op !== "move" && r.push(t);
-				for (let e of n) e.op !== "move" && i.push(e);
+function L(ee, Me) {
+	if (ee.length) {
+		let Ne = typeof ee[0][0] == "number" ? [ee] : ee, Pe = j(Ne[0], 1 * (1 + .2 * Me.roughness), Me), Fe = Me.disableMultiStroke ? [] : j(Ne[0], 1.5 * (1 + .22 * Me.roughness), z(Me));
+		for (let ee = 1; ee < Ne.length; ee++) {
+			let Ie = Ne[ee];
+			if (Ie.length) {
+				let ee = j(Ie, 1 * (1 + .2 * Me.roughness), Me), Ne = Me.disableMultiStroke ? [] : j(Ie, 1.5 * (1 + .22 * Me.roughness), z(Me));
+				for (let Me of ee) Me.op !== "move" && Pe.push(Me);
+				for (let ee of Ne) ee.op !== "move" && Fe.push(ee);
 			}
 		}
 		return {
 			type: "path",
-			ops: r.concat(i)
+			ops: Pe.concat(Fe)
 		};
 	}
 	return {
@@ -621,352 +620,352 @@ function D(e, t) {
 		ops: []
 	};
 }
-function O(e, t, n) {
-	let r = Math.sqrt(2 * Math.PI * Math.sqrt(((e / 2) ** 2 + (t / 2) ** 2) / 2)), i = Math.ceil(Math.max(n.curveStepCount, n.curveStepCount / Math.sqrt(200) * r)), a = 2 * Math.PI / i, o = Math.abs(e / 2), s = Math.abs(t / 2), c = 1 - n.curveFitting;
-	return o += L(o * c, n), s += L(s * c, n), {
-		increment: a,
-		rx: o,
-		ry: s
+function T(ee, Me, Ne) {
+	let Pe = Math.sqrt(2 * Math.PI * Math.sqrt(((ee / 2) ** 2 + (Me / 2) ** 2) / 2)), Fe = Math.ceil(Math.max(Ne.curveStepCount, Ne.curveStepCount / Math.sqrt(200) * Pe)), Ie = 2 * Math.PI / Fe, Le = Math.abs(ee / 2), Re = Math.abs(Me / 2), ze = 1 - Ne.curveFitting;
+	return Le += G(Le * ze, Ne), Re += G(Re * ze, Ne), {
+		increment: Ie,
+		rx: Le,
+		ry: Re
 	};
 }
-function k(e, t, n, r) {
-	let [i, a] = H(r.increment, e, t, r.rx, r.ry, 1, r.increment * I(.1, I(.4, 1, n), n), n), o = V(i, null, n);
-	if (!n.disableMultiStroke && n.roughness !== 0) {
-		let [i] = H(r.increment, e, t, r.rx, r.ry, 1.5, 0, n), a = V(i, null, n);
-		o = o.concat(a);
+function D(ee, Me, Ne, Pe) {
+	let [Fe, Ie] = F(Pe.increment, ee, Me, Pe.rx, Pe.ry, 1, Pe.increment * E(.1, E(.4, 1, Ne), Ne), Ne), Le = q(Fe, null, Ne);
+	if (!Ne.disableMultiStroke && Ne.roughness !== 0) {
+		let [Fe] = F(Pe.increment, ee, Me, Pe.rx, Pe.ry, 1.5, 0, Ne), Ie = q(Fe, null, Ne);
+		Le = Le.concat(Ie);
 	}
 	return {
-		estimatedPoints: a,
+		estimatedPoints: Ie,
 		opset: {
 			type: "path",
-			ops: o
+			ops: Le
 		}
 	};
 }
-function A(e, t, n, r, i, a, o, s, c) {
-	let l = e, u = t, d = Math.abs(n / 2), f = Math.abs(r / 2);
-	d += L(.01 * d, c), f += L(.01 * f, c);
-	let p = i, m = a;
-	for (; p < 0;) p += 2 * Math.PI, m += 2 * Math.PI;
-	m - p > 2 * Math.PI && (p = 0, m = 2 * Math.PI);
-	let h = 2 * Math.PI / c.curveStepCount, g = Math.min(h / 2, (m - p) / 2), _ = U(g, l, u, d, f, p, m, 1, c);
-	if (!c.disableMultiStroke) {
-		let e = U(g, l, u, d, f, p, m, 1.5, c);
-		_.push(...e);
-	}
-	return o && (s ? _.push(...R(l, u, l + d * Math.cos(p), u + f * Math.sin(p), c), ...R(l, u, l + d * Math.cos(m), u + f * Math.sin(m), c)) : _.push({
+function A(ee, Me, Ne, Pe, Fe, Ie, Le, Re, ze) {
+	let Be = ee, Ve = Me, He = Math.abs(Ne / 2), Ue = Math.abs(Pe / 2);
+	He += G(.01 * He, ze), Ue += G(.01 * Ue, ze);
+	let We = Fe, Ge = Ie;
+	for (; We < 0;) We += 2 * Math.PI, Ge += 2 * Math.PI;
+	Ge - We > 2 * Math.PI && (We = 0, Ge = 2 * Math.PI);
+	let Ke = 2 * Math.PI / ze.curveStepCount, qe = Math.min(Ke / 2, (Ge - We) / 2), Je = V(qe, Be, Ve, He, Ue, We, Ge, 1, ze);
+	if (!ze.disableMultiStroke) {
+		let ee = V(qe, Be, Ve, He, Ue, We, Ge, 1.5, ze);
+		Je.push(...ee);
+	}
+	return Le && (Re ? Je.push(...$(Be, Ve, Be + He * Math.cos(We), Ve + Ue * Math.sin(We), ze), ...$(Be, Ve, Be + He * Math.cos(Ge), Ve + Ue * Math.sin(Ge), ze)) : Je.push({
 		op: "lineTo",
-		data: [l, u]
+		data: [Be, Ve]
 	}, {
 		op: "lineTo",
-		data: [l + d * Math.cos(p), u + f * Math.sin(p)]
+		data: [Be + He * Math.cos(We), Ve + Ue * Math.sin(We)]
 	})), {
 		type: "path",
-		ops: _
+		ops: Je
 	};
 }
-function j(e, t) {
-	let n = b(y(v(e))), r = [], i = [0, 0], a = [0, 0];
-	for (let { key: e, data: o } of n) switch (e) {
+function _(ee, Me) {
+	let Ne = m(y(b(ee))), Pe = [], Fe = [0, 0], Ie = [0, 0];
+	for (let { key: ee, data: Le } of Ne) switch (ee) {
 		case "M":
-			a = [o[0], o[1]], i = [o[0], o[1]];
+			Ie = [Le[0], Le[1]], Fe = [Le[0], Le[1]];
 			break;
 		case "L":
-			r.push(...R(a[0], a[1], o[0], o[1], t)), a = [o[0], o[1]];
+			Pe.push(...$(Ie[0], Ie[1], Le[0], Le[1], Me)), Ie = [Le[0], Le[1]];
 			break;
 		case "C": {
-			let [e, n, i, s, c, l] = o;
-			r.push(...ee(e, n, i, s, c, l, a, t)), a = [c, l];
+			let [ee, Ne, Fe, Re, ze, Be] = Le;
+			Pe.push(...Z(ee, Ne, Fe, Re, ze, Be, Ie, Me)), Ie = [ze, Be];
 			break;
 		}
-		case "Z": r.push(...R(a[0], a[1], i[0], i[1], t)), a = [i[0], i[1]];
+		case "Z": Pe.push(...$(Ie[0], Ie[1], Fe[0], Fe[1], Me)), Ie = [Fe[0], Fe[1]];
 	}
 	return {
 		type: "path",
-		ops: r
+		ops: Pe
 	};
 }
-function M(e, t) {
-	let n = [];
-	for (let r of e) if (r.length) {
-		let e = t.maxRandomnessOffset || 0, i = r.length;
-		if (i > 2) {
-			n.push({
+function I(ee, Me) {
+	let Ne = [];
+	for (let Pe of ee) if (Pe.length) {
+		let ee = Me.maxRandomnessOffset || 0, Fe = Pe.length;
+		if (Fe > 2) {
+			Ne.push({
 				op: "move",
-				data: [r[0][0] + L(e, t), r[0][1] + L(e, t)]
+				data: [Pe[0][0] + G(ee, Me), Pe[0][1] + G(ee, Me)]
 			});
-			for (let a = 1; a < i; a++) n.push({
+			for (let Ie = 1; Ie < Fe; Ie++) Ne.push({
 				op: "lineTo",
-				data: [r[a][0] + L(e, t), r[a][1] + L(e, t)]
+				data: [Pe[Ie][0] + G(ee, Me), Pe[Ie][1] + G(ee, Me)]
 			});
 		}
 	}
 	return {
 		type: "fillPath",
-		ops: n
+		ops: Ne
 	};
 }
-function N(e, t) {
-	return function(e, t) {
-		let n = e.fillStyle || "hachure";
-		if (!d[n]) switch (n) {
+function C(ee, Me) {
+	return function(ee, Me) {
+		let Ne = ee.fillStyle || "hachure";
+		if (!u[Ne]) switch (Ne) {
 			case "zigzag":
-				d[n] || (d[n] = new o(t));
+				u[Ne] || (u[Ne] = new h(Me));
 				break;
 			case "cross-hatch":
-				d[n] || (d[n] = new s(t));
+				u[Ne] || (u[Ne] = new r(Me));
 				break;
 			case "dots":
-				d[n] || (d[n] = new c(t));
+				u[Ne] || (u[Ne] = new i(Me));
 				break;
 			case "dashed":
-				d[n] || (d[n] = new l(t));
+				u[Ne] || (u[Ne] = new c(Me));
 				break;
 			case "zigzag-line":
-				d[n] || (d[n] = new u(t));
+				u[Ne] || (u[Ne] = new l(Me));
 				break;
-			default: n = "hachure", d[n] || (d[n] = new i(t));
+			default: Ne = "hachure", u[Ne] || (u[Ne] = new o(Me));
 		}
-		return d[n];
-	}(t, C).fillPolygons(e, t);
+		return u[Ne];
+	}(Me, P).fillPolygons(ee, Me);
 }
-function P(e) {
-	let t = Object.assign({}, e);
-	return t.randomizer = void 0, e.seed && (t.seed = e.seed + 1), t;
+function z(ee) {
+	let Me = Object.assign({}, ee);
+	return Me.randomizer = void 0, ee.seed && (Me.seed = ee.seed + 1), Me;
 }
-function F(e) {
-	return e.randomizer ||= new f(e.seed || 0), e.randomizer.next();
+function W(ee) {
+	return ee.randomizer ||= new p(ee.seed || 0), ee.randomizer.next();
 }
-function I(e, t, n, r = 1) {
-	return n.roughness * r * (F(n) * (t - e) + e);
+function E(ee, Me, Ne, Pe = 1) {
+	return Ne.roughness * Pe * (W(Ne) * (Me - ee) + ee);
 }
-function L(e, t, n = 1) {
-	return I(-e, e, t, n);
+function G(ee, Me, Ne = 1) {
+	return E(-ee, ee, Me, Ne);
 }
-function R(e, t, n, r, i, a = !1) {
-	let o = a ? i.disableMultiStrokeFill : i.disableMultiStroke, s = z(e, t, n, r, i, !0, !1);
-	if (o) return s;
-	let c = z(e, t, n, r, i, !0, !0);
-	return s.concat(c);
+function $(ee, Me, Ne, Pe, Fe, Ie = !1) {
+	let Le = Ie ? Fe.disableMultiStrokeFill : Fe.disableMultiStroke, Re = R(ee, Me, Ne, Pe, Fe, !0, !1);
+	if (Le) return Re;
+	let ze = R(ee, Me, Ne, Pe, Fe, !0, !0);
+	return Re.concat(ze);
 }
-function z(e, t, n, r, i, a, o) {
-	let s = (e - n) ** 2 + (t - r) ** 2, c = Math.sqrt(s), l = 1;
-	l = c < 200 ? 1 : c > 500 ? .4 : -.0016668 * c + 1.233334;
-	let u = i.maxRandomnessOffset || 0;
-	u * u * 100 > s && (u = c / 10);
-	let d = u / 2, f = .2 + .2 * F(i), p = i.bowing * i.maxRandomnessOffset * (r - t) / 200, m = i.bowing * i.maxRandomnessOffset * (e - n) / 200;
-	p = L(p, i, l), m = L(m, i, l);
-	let h = [], g = () => L(d, i, l), _ = () => L(u, i, l), v = i.preserveVertices;
-	return a && (o ? h.push({
+function R(ee, Me, Ne, Pe, Fe, Ie, Le) {
+	let Re = (ee - Ne) ** 2 + (Me - Pe) ** 2, ze = Math.sqrt(Re), Be = 1;
+	Be = ze < 200 ? 1 : ze > 500 ? .4 : -.0016668 * ze + 1.233334;
+	let Ve = Fe.maxRandomnessOffset || 0;
+	Ve * Ve * 100 > Re && (Ve = ze / 10);
+	let He = Ve / 2, Ue = .2 + .2 * W(Fe), We = Fe.bowing * Fe.maxRandomnessOffset * (Pe - Me) / 200, Ge = Fe.bowing * Fe.maxRandomnessOffset * (ee - Ne) / 200;
+	We = G(We, Fe, Be), Ge = G(Ge, Fe, Be);
+	let Ke = [], qe = () => G(He, Fe, Be), Je = () => G(Ve, Fe, Be), Ye = Fe.preserveVertices;
+	return Ie && (Le ? Ke.push({
 		op: "move",
-		data: [e + (v ? 0 : g()), t + (v ? 0 : g())]
-	}) : h.push({
+		data: [ee + (Ye ? 0 : qe()), Me + (Ye ? 0 : qe())]
+	}) : Ke.push({
 		op: "move",
-		data: [e + (v ? 0 : L(u, i, l)), t + (v ? 0 : L(u, i, l))]
-	})), o ? h.push({
+		data: [ee + (Ye ? 0 : G(Ve, Fe, Be)), Me + (Ye ? 0 : G(Ve, Fe, Be))]
+	})), Le ? Ke.push({
 		op: "bcurveTo",
 		data: [
-			p + e + (n - e) * f + g(),
-			m + t + (r - t) * f + g(),
-			p + e + 2 * (n - e) * f + g(),
-			m + t + 2 * (r - t) * f + g(),
-			n + (v ? 0 : g()),
-			r + (v ? 0 : g())
+			We + ee + (Ne - ee) * Ue + qe(),
+			Ge + Me + (Pe - Me) * Ue + qe(),
+			We + ee + 2 * (Ne - ee) * Ue + qe(),
+			Ge + Me + 2 * (Pe - Me) * Ue + qe(),
+			Ne + (Ye ? 0 : qe()),
+			Pe + (Ye ? 0 : qe())
 		]
-	}) : h.push({
+	}) : Ke.push({
 		op: "bcurveTo",
 		data: [
-			p + e + (n - e) * f + _(),
-			m + t + (r - t) * f + _(),
-			p + e + 2 * (n - e) * f + _(),
-			m + t + 2 * (r - t) * f + _(),
-			n + (v ? 0 : _()),
-			r + (v ? 0 : _())
+			We + ee + (Ne - ee) * Ue + Je(),
+			Ge + Me + (Pe - Me) * Ue + Je(),
+			We + ee + 2 * (Ne - ee) * Ue + Je(),
+			Ge + Me + 2 * (Pe - Me) * Ue + Je(),
+			Ne + (Ye ? 0 : Je()),
+			Pe + (Ye ? 0 : Je())
 		]
-	}), h;
+	}), Ke;
 }
-function B(e, t, n) {
-	if (!e.length) return [];
-	let r = [];
-	r.push([e[0][0] + L(t, n), e[0][1] + L(t, n)]), r.push([e[0][0] + L(t, n), e[0][1] + L(t, n)]);
-	for (let i = 1; i < e.length; i++) r.push([e[i][0] + L(t, n), e[i][1] + L(t, n)]), i === e.length - 1 && r.push([e[i][0] + L(t, n), e[i][1] + L(t, n)]);
-	return V(r, null, n);
+function j(ee, Me, Ne) {
+	if (!ee.length) return [];
+	let Pe = [];
+	Pe.push([ee[0][0] + G(Me, Ne), ee[0][1] + G(Me, Ne)]), Pe.push([ee[0][0] + G(Me, Ne), ee[0][1] + G(Me, Ne)]);
+	for (let Fe = 1; Fe < ee.length; Fe++) Pe.push([ee[Fe][0] + G(Me, Ne), ee[Fe][1] + G(Me, Ne)]), Fe === ee.length - 1 && Pe.push([ee[Fe][0] + G(Me, Ne), ee[Fe][1] + G(Me, Ne)]);
+	return q(Pe, null, Ne);
 }
-function V(e, t, n) {
-	let r = e.length, i = [];
-	if (r > 3) {
-		let a = [], o = 1 - n.curveTightness;
-		i.push({
+function q(ee, Me, Ne) {
+	let Pe = ee.length, Fe = [];
+	if (Pe > 3) {
+		let Ie = [], Le = 1 - Ne.curveTightness;
+		Fe.push({
 			op: "move",
-			data: [e[1][0], e[1][1]]
+			data: [ee[1][0], ee[1][1]]
 		});
-		for (let t = 1; t + 2 < r; t++) {
-			let n = e[t];
-			a[0] = [n[0], n[1]], a[1] = [n[0] + (o * e[t + 1][0] - o * e[t - 1][0]) / 6, n[1] + (o * e[t + 1][1] - o * e[t - 1][1]) / 6], a[2] = [e[t + 1][0] + (o * e[t][0] - o * e[t + 2][0]) / 6, e[t + 1][1] + (o * e[t][1] - o * e[t + 2][1]) / 6], a[3] = [e[t + 1][0], e[t + 1][1]], i.push({
+		for (let Me = 1; Me + 2 < Pe; Me++) {
+			let Ne = ee[Me];
+			Ie[0] = [Ne[0], Ne[1]], Ie[1] = [Ne[0] + (Le * ee[Me + 1][0] - Le * ee[Me - 1][0]) / 6, Ne[1] + (Le * ee[Me + 1][1] - Le * ee[Me - 1][1]) / 6], Ie[2] = [ee[Me + 1][0] + (Le * ee[Me][0] - Le * ee[Me + 2][0]) / 6, ee[Me + 1][1] + (Le * ee[Me][1] - Le * ee[Me + 2][1]) / 6], Ie[3] = [ee[Me + 1][0], ee[Me + 1][1]], Fe.push({
 				op: "bcurveTo",
 				data: [
-					a[1][0],
-					a[1][1],
-					a[2][0],
-					a[2][1],
-					a[3][0],
-					a[3][1]
+					Ie[1][0],
+					Ie[1][1],
+					Ie[2][0],
+					Ie[2][1],
+					Ie[3][0],
+					Ie[3][1]
 				]
 			});
 		}
-		if (t && t.length === 2) {
-			let e = n.maxRandomnessOffset;
-			i.push({
+		if (Me && Me.length === 2) {
+			let ee = Ne.maxRandomnessOffset;
+			Fe.push({
 				op: "lineTo",
-				data: [t[0] + L(e, n), t[1] + L(e, n)]
+				data: [Me[0] + G(ee, Ne), Me[1] + G(ee, Ne)]
 			});
 		}
-	} else r === 3 ? (i.push({
+	} else Pe === 3 ? (Fe.push({
 		op: "move",
-		data: [e[1][0], e[1][1]]
-	}), i.push({
+		data: [ee[1][0], ee[1][1]]
+	}), Fe.push({
 		op: "bcurveTo",
 		data: [
-			e[1][0],
-			e[1][1],
-			e[2][0],
-			e[2][1],
-			e[2][0],
-			e[2][1]
+			ee[1][0],
+			ee[1][1],
+			ee[2][0],
+			ee[2][1],
+			ee[2][0],
+			ee[2][1]
 		]
-	})) : r === 2 && i.push(...z(e[0][0], e[0][1], e[1][0], e[1][1], n, !0, !0));
-	return i;
+	})) : Pe === 2 && Fe.push(...R(ee[0][0], ee[0][1], ee[1][0], ee[1][1], Ne, !0, !0));
+	return Fe;
 }
-function H(e, t, n, r, i, a, o, s) {
-	let c = [], l = [];
-	if (s.roughness === 0) {
-		e /= 4, l.push([t + r * Math.cos(-e), n + i * Math.sin(-e)]);
-		for (let a = 0; a <= 2 * Math.PI; a += e) {
-			let e = [t + r * Math.cos(a), n + i * Math.sin(a)];
-			c.push(e), l.push(e);
+function F(ee, Me, Ne, Pe, Fe, Ie, Le, Re) {
+	let ze = [], Be = [];
+	if (Re.roughness === 0) {
+		ee /= 4, Be.push([Me + Pe * Math.cos(-ee), Ne + Fe * Math.sin(-ee)]);
+		for (let Ie = 0; Ie <= 2 * Math.PI; Ie += ee) {
+			let ee = [Me + Pe * Math.cos(Ie), Ne + Fe * Math.sin(Ie)];
+			ze.push(ee), Be.push(ee);
 		}
-		l.push([t + r * Math.cos(0), n + i * Math.sin(0)]), l.push([t + r * Math.cos(e), n + i * Math.sin(e)]);
+		Be.push([Me + Pe * Math.cos(0), Ne + Fe * Math.sin(0)]), Be.push([Me + Pe * Math.cos(ee), Ne + Fe * Math.sin(ee)]);
 	} else {
-		let u = L(.5, s) - Math.PI / 2;
-		l.push([L(a, s) + t + .9 * r * Math.cos(u - e), L(a, s) + n + .9 * i * Math.sin(u - e)]);
-		let d = 2 * Math.PI + u - .01;
-		for (let o = u; o < d; o += e) {
-			let e = [L(a, s) + t + r * Math.cos(o), L(a, s) + n + i * Math.sin(o)];
-			c.push(e), l.push(e);
+		let Ve = G(.5, Re) - Math.PI / 2;
+		Be.push([G(Ie, Re) + Me + .9 * Pe * Math.cos(Ve - ee), G(Ie, Re) + Ne + .9 * Fe * Math.sin(Ve - ee)]);
+		let He = 2 * Math.PI + Ve - .01;
+		for (let Le = Ve; Le < He; Le += ee) {
+			let ee = [G(Ie, Re) + Me + Pe * Math.cos(Le), G(Ie, Re) + Ne + Fe * Math.sin(Le)];
+			ze.push(ee), Be.push(ee);
 		}
-		l.push([L(a, s) + t + r * Math.cos(u + 2 * Math.PI + .5 * o), L(a, s) + n + i * Math.sin(u + 2 * Math.PI + .5 * o)]), l.push([L(a, s) + t + .98 * r * Math.cos(u + o), L(a, s) + n + .98 * i * Math.sin(u + o)]), l.push([L(a, s) + t + .9 * r * Math.cos(u + .5 * o), L(a, s) + n + .9 * i * Math.sin(u + .5 * o)]);
+		Be.push([G(Ie, Re) + Me + Pe * Math.cos(Ve + 2 * Math.PI + .5 * Le), G(Ie, Re) + Ne + Fe * Math.sin(Ve + 2 * Math.PI + .5 * Le)]), Be.push([G(Ie, Re) + Me + .98 * Pe * Math.cos(Ve + Le), G(Ie, Re) + Ne + .98 * Fe * Math.sin(Ve + Le)]), Be.push([G(Ie, Re) + Me + .9 * Pe * Math.cos(Ve + .5 * Le), G(Ie, Re) + Ne + .9 * Fe * Math.sin(Ve + .5 * Le)]);
 	}
-	return [l, c];
+	return [Be, ze];
 }
-function U(e, t, n, r, i, a, o, s, c) {
-	let l = a + L(.1, c), u = [];
-	u.push([L(s, c) + t + .9 * r * Math.cos(l - e), L(s, c) + n + .9 * i * Math.sin(l - e)]);
-	for (let a = l; a <= o; a += e) u.push([L(s, c) + t + r * Math.cos(a), L(s, c) + n + i * Math.sin(a)]);
-	return u.push([t + r * Math.cos(o), n + i * Math.sin(o)]), u.push([t + r * Math.cos(o), n + i * Math.sin(o)]), V(u, null, c);
+function V(ee, Me, Ne, Pe, Fe, Ie, Le, Re, ze) {
+	let Be = Ie + G(.1, ze), Ve = [];
+	Ve.push([G(Re, ze) + Me + .9 * Pe * Math.cos(Be - ee), G(Re, ze) + Ne + .9 * Fe * Math.sin(Be - ee)]);
+	for (let Ie = Be; Ie <= Le; Ie += ee) Ve.push([G(Re, ze) + Me + Pe * Math.cos(Ie), G(Re, ze) + Ne + Fe * Math.sin(Ie)]);
+	return Ve.push([Me + Pe * Math.cos(Le), Ne + Fe * Math.sin(Le)]), Ve.push([Me + Pe * Math.cos(Le), Ne + Fe * Math.sin(Le)]), q(Ve, null, ze);
 }
-function ee(e, t, n, r, i, a, o, s) {
-	let c = [], l = [s.maxRandomnessOffset || 1, (s.maxRandomnessOffset || 1) + .3], u = [0, 0], d = s.disableMultiStroke ? 1 : 2, f = s.preserveVertices;
-	for (let p = 0; p < d; p++) p === 0 ? c.push({
+function Z(ee, Me, Ne, Pe, Fe, Ie, Le, Re) {
+	let ze = [], Be = [Re.maxRandomnessOffset || 1, (Re.maxRandomnessOffset || 1) + .3], Ve = [0, 0], He = Re.disableMultiStroke ? 1 : 2, Ue = Re.preserveVertices;
+	for (let We = 0; We < He; We++) We === 0 ? ze.push({
 		op: "move",
-		data: [o[0], o[1]]
-	}) : c.push({
+		data: [Le[0], Le[1]]
+	}) : ze.push({
 		op: "move",
-		data: [o[0] + (f ? 0 : L(l[0], s)), o[1] + (f ? 0 : L(l[0], s))]
-	}), u = f ? [i, a] : [i + L(l[p], s), a + L(l[p], s)], c.push({
+		data: [Le[0] + (Ue ? 0 : G(Be[0], Re)), Le[1] + (Ue ? 0 : G(Be[0], Re))]
+	}), Ve = Ue ? [Fe, Ie] : [Fe + G(Be[We], Re), Ie + G(Be[We], Re)], ze.push({
 		op: "bcurveTo",
 		data: [
-			e + L(l[p], s),
-			t + L(l[p], s),
-			n + L(l[p], s),
-			r + L(l[p], s),
-			u[0],
-			u[1]
+			ee + G(Be[We], Re),
+			Me + G(Be[We], Re),
+			Ne + G(Be[We], Re),
+			Pe + G(Be[We], Re),
+			Ve[0],
+			Ve[1]
 		]
 	});
-	return c;
+	return ze;
 }
-function W(e) {
-	return [...e];
+function Q(ee) {
+	return [...ee];
 }
-function G(e, t = 0) {
-	let n = e.length;
-	if (n < 3) throw Error("A curve must have at least three points.");
-	let r = [];
-	if (n === 3) r.push(W(e[0]), W(e[1]), W(e[2]), W(e[2]));
+function H(ee, Me = 0) {
+	let Ne = ee.length;
+	if (Ne < 3) throw Error("A curve must have at least three points.");
+	let Pe = [];
+	if (Ne === 3) Pe.push(Q(ee[0]), Q(ee[1]), Q(ee[2]), Q(ee[2]));
 	else {
-		let n = [];
-		n.push(e[0], e[0]);
-		for (let t = 1; t < e.length; t++) n.push(e[t]), t === e.length - 1 && n.push(e[t]);
-		let i = [], a = 1 - t;
-		r.push(W(n[0]));
-		for (let e = 1; e + 2 < n.length; e++) {
-			let t = n[e];
-			i[0] = [t[0], t[1]], i[1] = [t[0] + (a * n[e + 1][0] - a * n[e - 1][0]) / 6, t[1] + (a * n[e + 1][1] - a * n[e - 1][1]) / 6], i[2] = [n[e + 1][0] + (a * n[e][0] - a * n[e + 2][0]) / 6, n[e + 1][1] + (a * n[e][1] - a * n[e + 2][1]) / 6], i[3] = [n[e + 1][0], n[e + 1][1]], r.push(i[1], i[2], i[3]);
+		let Ne = [];
+		Ne.push(ee[0], ee[0]);
+		for (let Me = 1; Me < ee.length; Me++) Ne.push(ee[Me]), Me === ee.length - 1 && Ne.push(ee[Me]);
+		let Fe = [], Ie = 1 - Me;
+		Pe.push(Q(Ne[0]));
+		for (let ee = 1; ee + 2 < Ne.length; ee++) {
+			let Me = Ne[ee];
+			Fe[0] = [Me[0], Me[1]], Fe[1] = [Me[0] + (Ie * Ne[ee + 1][0] - Ie * Ne[ee - 1][0]) / 6, Me[1] + (Ie * Ne[ee + 1][1] - Ie * Ne[ee - 1][1]) / 6], Fe[2] = [Ne[ee + 1][0] + (Ie * Ne[ee][0] - Ie * Ne[ee + 2][0]) / 6, Ne[ee + 1][1] + (Ie * Ne[ee][1] - Ie * Ne[ee + 2][1]) / 6], Fe[3] = [Ne[ee + 1][0], Ne[ee + 1][1]], Pe.push(Fe[1], Fe[2], Fe[3]);
 		}
 	}
-	return r;
+	return Pe;
 }
-function K(e, t) {
-	return (e[0] - t[0]) ** 2 + (e[1] - t[1]) ** 2;
+function N(ee, Me) {
+	return (ee[0] - Me[0]) ** 2 + (ee[1] - Me[1]) ** 2;
 }
-function te(e, t, n) {
-	let r = K(t, n);
-	if (r === 0) return K(e, t);
-	let i = ((e[0] - t[0]) * (n[0] - t[0]) + (e[1] - t[1]) * (n[1] - t[1])) / r;
-	return i = Math.max(0, Math.min(1, i)), K(e, q(t, n, i));
+function B(ee, Me, Ne) {
+	let Pe = N(Me, Ne);
+	if (Pe === 0) return N(ee, Me);
+	let Fe = ((ee[0] - Me[0]) * (Ne[0] - Me[0]) + (ee[1] - Me[1]) * (Ne[1] - Me[1])) / Pe;
+	return Fe = Math.max(0, Math.min(1, Fe)), N(ee, J(Me, Ne, Fe));
 }
-function q(e, t, n) {
-	return [e[0] + (t[0] - e[0]) * n, e[1] + (t[1] - e[1]) * n];
+function J(ee, Me, Ne) {
+	return [ee[0] + (Me[0] - ee[0]) * Ne, ee[1] + (Me[1] - ee[1]) * Ne];
 }
-function J(e, t, n, r) {
-	let i = r || [];
-	if (function(e, t) {
-		let n = e[t + 0], r = e[t + 1], i = e[t + 2], a = e[t + 3], o = 3 * r[0] - 2 * n[0] - a[0];
-		o *= o;
-		let s = 3 * r[1] - 2 * n[1] - a[1];
-		s *= s;
-		let c = 3 * i[0] - 2 * a[0] - n[0];
-		c *= c;
-		let l = 3 * i[1] - 2 * a[1] - n[1];
-		return l *= l, o < c && (o = c), s < l && (s = l), o + s;
-	}(e, t) < n) {
-		let n = e[t + 0];
-		i.length ? (a = i[i.length - 1], o = n, Math.sqrt(K(a, o))) > 1 && i.push(n) : i.push(n), i.push(e[t + 3]);
+function K(ee, Me, Ne, Pe) {
+	let Fe = Pe || [];
+	if (function(ee, Me) {
+		let Ne = ee[Me + 0], Pe = ee[Me + 1], Fe = ee[Me + 2], Ie = ee[Me + 3], Le = 3 * Pe[0] - 2 * Ne[0] - Ie[0];
+		Le *= Le;
+		let Re = 3 * Pe[1] - 2 * Ne[1] - Ie[1];
+		Re *= Re;
+		let ze = 3 * Fe[0] - 2 * Ie[0] - Ne[0];
+		ze *= ze;
+		let Be = 3 * Fe[1] - 2 * Ie[1] - Ne[1];
+		return Be *= Be, Le < ze && (Le = ze), Re < Be && (Re = Be), Le + Re;
+	}(ee, Me) < Ne) {
+		let Ne = ee[Me + 0];
+		Fe.length ? (Ie = Fe[Fe.length - 1], Le = Ne, Math.sqrt(N(Ie, Le))) > 1 && Fe.push(Ne) : Fe.push(Ne), Fe.push(ee[Me + 3]);
 	} else {
-		let r = .5, a = e[t + 0], o = e[t + 1], s = e[t + 2], c = e[t + 3], l = q(a, o, r), u = q(o, s, r), d = q(s, c, r), f = q(l, u, r), p = q(u, d, r), m = q(f, p, r);
-		J([
-			a,
-			l,
-			f,
-			m
-		], 0, n, i), J([
-			m,
-			p,
-			d,
-			c
-		], 0, n, i);
-	}
-	var a, o;
-	return i;
+		let Pe = .5, Ie = ee[Me + 0], Le = ee[Me + 1], Re = ee[Me + 2], ze = ee[Me + 3], Be = J(Ie, Le, Pe), Ve = J(Le, Re, Pe), He = J(Re, ze, Pe), Ue = J(Be, Ve, Pe), We = J(Ve, He, Pe), Ge = J(Ue, We, Pe);
+		K([
+			Ie,
+			Be,
+			Ue,
+			Ge
+		], 0, Ne, Fe), K([
+			Ge,
+			We,
+			He,
+			ze
+		], 0, Ne, Fe);
+	}
+	var Ie, Le;
+	return Fe;
 }
-function ne(e, t) {
-	return Y(e, 0, e.length, t);
+function U(ee, Me) {
+	return X(ee, 0, ee.length, Me);
 }
-function Y(e, t, n, r, i) {
-	let a = i || [], o = e[t], s = e[n - 1], c = 0, l = 1;
-	for (let r = t + 1; r < n - 1; ++r) {
-		let t = te(e[r], o, s);
-		t > c && (c = t, l = r);
+function X(ee, Me, Ne, Pe, Fe) {
+	let Ie = Fe || [], Le = ee[Me], Re = ee[Ne - 1], ze = 0, Be = 1;
+	for (let Pe = Me + 1; Pe < Ne - 1; ++Pe) {
+		let Me = B(ee[Pe], Le, Re);
+		Me > ze && (ze = Me, Be = Pe);
 	}
-	return Math.sqrt(c) > r ? (Y(e, t, l + 1, r, a), Y(e, l, n, r, a)) : (a.length || a.push(o), a.push(s)), a;
+	return Math.sqrt(ze) > Pe ? (X(ee, Me, Be + 1, Pe, Ie), X(ee, Be, Ne, Pe, Ie)) : (Ie.length || Ie.push(Le), Ie.push(Re)), Ie;
 }
-function X(e, t = .15, n) {
-	let r = [], i = (e.length - 1) / 3;
-	for (let n = 0; n < i; n++) J(e, 3 * n, t, r);
-	return n && n > 0 ? Y(r, 0, r.length, n) : r;
+function Y(ee, Me = .15, Ne) {
+	let Pe = [], Fe = (ee.length - 1) / 3;
+	for (let Ne = 0; Ne < Fe; Ne++) K(ee, 3 * Ne, Me, Pe);
+	return Ne && Ne > 0 ? X(Pe, 0, Pe.length, Ne) : Pe;
 }
-var Z = "none", Q = class {
-	constructor(e) {
+var tt = "none", et = class {
+	constructor(ee) {
 		this.defaultOptions = {
 			maxRandomnessOffset: 2,
 			roughness: 1,
@@ -988,245 +987,245 @@ var Z = "none", Q = class {
 			disableMultiStrokeFill: !1,
 			preserveVertices: !1,
 			fillShapeRoughnessGain: .8
-		}, this.config = e || {}, this.config.options && (this.defaultOptions = this._o(this.config.options));
+		}, this.config = ee || {}, this.config.options && (this.defaultOptions = this._o(this.config.options));
 	}
 	static newSeed() {
 		return Math.floor(Math.random() * 2 ** 31);
 	}
-	_o(e) {
-		return e ? Object.assign({}, this.defaultOptions, e) : this.defaultOptions;
+	_o(ee) {
+		return ee ? Object.assign({}, this.defaultOptions, ee) : this.defaultOptions;
 	}
-	_d(e, t, n) {
+	_d(ee, Me, Ne) {
 		return {
-			shape: e,
-			sets: t || [],
-			options: n || this.defaultOptions
+			shape: ee,
+			sets: Me || [],
+			options: Ne || this.defaultOptions
 		};
 	}
-	line(e, t, n, r, i) {
-		let a = this._o(i);
-		return this._d("line", [w(e, t, n, r, a)], a);
-	}
-	rectangle(e, t, n, r, i) {
-		let a = this._o(i), o = [], s = E(e, t, n, r, a);
-		if (a.fill) {
-			let i = [
-				[e, t],
-				[e + n, t],
-				[e + n, t + r],
-				[e, t + r]
+	line(ee, Me, Ne, Pe, Fe) {
+		let Ie = this._o(Fe);
+		return this._d("line", [v(ee, Me, Ne, Pe, Ie)], Ie);
+	}
+	rectangle(ee, Me, Ne, Pe, Fe) {
+		let Ie = this._o(Fe), Le = [], Re = O(ee, Me, Ne, Pe, Ie);
+		if (Ie.fill) {
+			let Fe = [
+				[ee, Me],
+				[ee + Ne, Me],
+				[ee + Ne, Me + Pe],
+				[ee, Me + Pe]
 			];
-			a.fillStyle === "solid" ? o.push(M([i], a)) : o.push(N([i], a));
+			Ie.fillStyle === "solid" ? Le.push(I([Fe], Ie)) : Le.push(C([Fe], Ie));
 		}
-		return a.stroke !== Z && o.push(s), this._d("rectangle", o, a);
-	}
-	ellipse(e, t, n, r, i) {
-		let a = this._o(i), o = [], s = O(n, r, a), c = k(e, t, a, s);
-		if (a.fill) if (a.fillStyle === "solid") {
-			let n = k(e, t, a, s).opset;
-			n.type = "fillPath", o.push(n);
-		} else o.push(N([c.estimatedPoints], a));
-		return a.stroke !== Z && o.push(c.opset), this._d("ellipse", o, a);
-	}
-	circle(e, t, n, r) {
-		let i = this.ellipse(e, t, n, n, r);
-		return i.shape = "circle", i;
-	}
-	linearPath(e, t) {
-		let n = this._o(t);
-		return this._d("linearPath", [T(e, !1, n)], n);
-	}
-	arc(e, t, n, r, i, a, o = !1, s) {
-		let c = this._o(s), l = [], u = A(e, t, n, r, i, a, o, !0, c);
-		if (o && c.fill) if (c.fillStyle === "solid") {
-			let o = Object.assign({}, c);
-			o.disableMultiStroke = !0;
-			let s = A(e, t, n, r, i, a, !0, !1, o);
-			s.type = "fillPath", l.push(s);
-		} else l.push(function(e, t, n, r, i, a, o) {
-			let s = e, c = t, l = Math.abs(n / 2), u = Math.abs(r / 2);
-			l += L(.01 * l, o), u += L(.01 * u, o);
-			let d = i, f = a;
-			for (; d < 0;) d += 2 * Math.PI, f += 2 * Math.PI;
-			f - d > 2 * Math.PI && (d = 0, f = 2 * Math.PI);
-			let p = (f - d) / o.curveStepCount, m = [];
-			for (let e = d; e <= f; e += p) m.push([s + l * Math.cos(e), c + u * Math.sin(e)]);
-			return m.push([s + l * Math.cos(f), c + u * Math.sin(f)]), m.push([s, c]), N([m], o);
-		}(e, t, n, r, i, a, c));
-		return c.stroke !== Z && l.push(u), this._d("arc", l, c);
-	}
-	curve(e, t) {
-		let n = this._o(t), r = [], i = D(e, n);
-		if (n.fill && n.fill !== Z) if (n.fillStyle === "solid") {
-			let t = D(e, Object.assign(Object.assign({}, n), {
+		return Ie.stroke !== tt && Le.push(Re), this._d("rectangle", Le, Ie);
+	}
+	ellipse(ee, Me, Ne, Pe, Fe) {
+		let Ie = this._o(Fe), Le = [], Re = T(Ne, Pe, Ie), ze = D(ee, Me, Ie, Re);
+		if (Ie.fill) if (Ie.fillStyle === "solid") {
+			let Ne = D(ee, Me, Ie, Re).opset;
+			Ne.type = "fillPath", Le.push(Ne);
+		} else Le.push(C([ze.estimatedPoints], Ie));
+		return Ie.stroke !== tt && Le.push(ze.opset), this._d("ellipse", Le, Ie);
+	}
+	circle(ee, Me, Ne, Pe) {
+		let Fe = this.ellipse(ee, Me, Ne, Ne, Pe);
+		return Fe.shape = "circle", Fe;
+	}
+	linearPath(ee, Me) {
+		let Ne = this._o(Me);
+		return this._d("linearPath", [S(ee, !1, Ne)], Ne);
+	}
+	arc(ee, Me, Ne, Pe, Fe, Ie, Le = !1, Re) {
+		let ze = this._o(Re), Be = [], Ve = A(ee, Me, Ne, Pe, Fe, Ie, Le, !0, ze);
+		if (Le && ze.fill) if (ze.fillStyle === "solid") {
+			let Le = Object.assign({}, ze);
+			Le.disableMultiStroke = !0;
+			let Re = A(ee, Me, Ne, Pe, Fe, Ie, !0, !1, Le);
+			Re.type = "fillPath", Be.push(Re);
+		} else Be.push(function(ee, Me, Ne, Pe, Fe, Ie, Le) {
+			let Re = ee, ze = Me, Be = Math.abs(Ne / 2), Ve = Math.abs(Pe / 2);
+			Be += G(.01 * Be, Le), Ve += G(.01 * Ve, Le);
+			let He = Fe, Ue = Ie;
+			for (; He < 0;) He += 2 * Math.PI, Ue += 2 * Math.PI;
+			Ue - He > 2 * Math.PI && (He = 0, Ue = 2 * Math.PI);
+			let We = (Ue - He) / Le.curveStepCount, Ge = [];
+			for (let ee = He; ee <= Ue; ee += We) Ge.push([Re + Be * Math.cos(ee), ze + Ve * Math.sin(ee)]);
+			return Ge.push([Re + Be * Math.cos(Ue), ze + Ve * Math.sin(Ue)]), Ge.push([Re, ze]), C([Ge], Le);
+		}(ee, Me, Ne, Pe, Fe, Ie, ze));
+		return ze.stroke !== tt && Be.push(Ve), this._d("arc", Be, ze);
+	}
+	curve(ee, Me) {
+		let Ne = this._o(Me), Pe = [], Fe = L(ee, Ne);
+		if (Ne.fill && Ne.fill !== tt) if (Ne.fillStyle === "solid") {
+			let Me = L(ee, Object.assign(Object.assign({}, Ne), {
 				disableMultiStroke: !0,
-				roughness: n.roughness ? n.roughness + n.fillShapeRoughnessGain : 0
+				roughness: Ne.roughness ? Ne.roughness + Ne.fillShapeRoughnessGain : 0
 			}));
-			r.push({
+			Pe.push({
 				type: "fillPath",
-				ops: this._mergedShape(t.ops)
+				ops: this._mergedShape(Me.ops)
 			});
 		} else {
-			let t = [], i = e;
-			if (i.length) {
-				let e = typeof i[0][0] == "number" ? [i] : i;
-				for (let r of e) r.length < 3 ? t.push(...r) : r.length === 3 ? t.push(...X(G([
-					r[0],
-					r[0],
-					r[1],
-					r[2]
-				]), 10, (1 + n.roughness) / 2)) : t.push(...X(G(r), 10, (1 + n.roughness) / 2));
+			let Me = [], Fe = ee;
+			if (Fe.length) {
+				let ee = typeof Fe[0][0] == "number" ? [Fe] : Fe;
+				for (let Pe of ee) Pe.length < 3 ? Me.push(...Pe) : Pe.length === 3 ? Me.push(...Y(H([
+					Pe[0],
+					Pe[0],
+					Pe[1],
+					Pe[2]
+				]), 10, (1 + Ne.roughness) / 2)) : Me.push(...Y(H(Pe), 10, (1 + Ne.roughness) / 2));
 			}
-			t.length && r.push(N([t], n));
+			Me.length && Pe.push(C([Me], Ne));
 		}
-		return n.stroke !== Z && r.push(i), this._d("curve", r, n);
-	}
-	polygon(e, t) {
-		let n = this._o(t), r = [], i = T(e, !0, n);
-		return n.fill && (n.fillStyle === "solid" ? r.push(M([e], n)) : r.push(N([e], n))), n.stroke !== Z && r.push(i), this._d("polygon", r, n);
-	}
-	path(e, t) {
-		let n = this._o(t), r = [];
-		if (!e) return this._d("path", r, n);
-		e = (e || "").replace(/\n/g, " ").replace(/(-\s)/g, "-").replace("/(ss)/g", " ");
-		let i = n.fill && n.fill !== "transparent" && n.fill !== Z, a = n.stroke !== Z, o = !!(n.simplification && n.simplification < 1), s = function(e, t, n) {
-			let r = b(y(v(e))), i = [], a = [], o = [0, 0], s = [], c = () => {
-				s.length >= 4 && a.push(...X(s, t)), s = [];
-			}, l = () => {
-				c(), a.length && (i.push(a), a = []);
+		return Ne.stroke !== tt && Pe.push(Fe), this._d("curve", Pe, Ne);
+	}
+	polygon(ee, Me) {
+		let Ne = this._o(Me), Pe = [], Fe = S(ee, !0, Ne);
+		return Ne.fill && (Ne.fillStyle === "solid" ? Pe.push(I([ee], Ne)) : Pe.push(C([ee], Ne))), Ne.stroke !== tt && Pe.push(Fe), this._d("polygon", Pe, Ne);
+	}
+	path(ee, Me) {
+		let Ne = this._o(Me), Pe = [];
+		if (!ee) return this._d("path", Pe, Ne);
+		ee = (ee || "").replace(/\n/g, " ").replace(/(-\s)/g, "-").replace("/(ss)/g", " ");
+		let Fe = Ne.fill && Ne.fill !== "transparent" && Ne.fill !== tt, Ie = Ne.stroke !== tt, Le = !!(Ne.simplification && Ne.simplification < 1), Re = function(ee, Me, Ne) {
+			let Pe = m(y(b(ee))), Fe = [], Ie = [], Le = [0, 0], Re = [], ze = () => {
+				Re.length >= 4 && Ie.push(...Y(Re, Me)), Re = [];
+			}, Be = () => {
+				ze(), Ie.length && (Fe.push(Ie), Ie = []);
 			};
-			for (let { key: e, data: t } of r) switch (e) {
+			for (let { key: ee, data: Me } of Pe) switch (ee) {
 				case "M":
-					l(), o = [t[0], t[1]], a.push(o);
+					Be(), Le = [Me[0], Me[1]], Ie.push(Le);
 					break;
 				case "L":
-					c(), a.push([t[0], t[1]]);
+					ze(), Ie.push([Me[0], Me[1]]);
 					break;
 				case "C":
-					if (!s.length) {
-						let e = a.length ? a[a.length - 1] : o;
-						s.push([e[0], e[1]]);
+					if (!Re.length) {
+						let ee = Ie.length ? Ie[Ie.length - 1] : Le;
+						Re.push([ee[0], ee[1]]);
 					}
-					s.push([t[0], t[1]]), s.push([t[2], t[3]]), s.push([t[4], t[5]]);
+					Re.push([Me[0], Me[1]]), Re.push([Me[2], Me[3]]), Re.push([Me[4], Me[5]]);
 					break;
-				case "Z": c(), a.push([o[0], o[1]]);
+				case "Z": ze(), Ie.push([Le[0], Le[1]]);
 			}
-			if (l(), !n) return i;
-			let u = [];
-			for (let e of i) {
-				let t = ne(e, n);
-				t.length && u.push(t);
+			if (Be(), !Ne) return Fe;
+			let Ve = [];
+			for (let ee of Fe) {
+				let Me = U(ee, Ne);
+				Me.length && Ve.push(Me);
 			}
-			return u;
-		}(e, 1, o ? 4 - 4 * (n.simplification || 1) : (1 + n.roughness) / 2), c = j(e, n);
-		if (i) if (n.fillStyle === "solid") if (s.length === 1) {
-			let t = j(e, Object.assign(Object.assign({}, n), {
+			return Ve;
+		}(ee, 1, Le ? 4 - 4 * (Ne.simplification || 1) : (1 + Ne.roughness) / 2), ze = _(ee, Ne);
+		if (Fe) if (Ne.fillStyle === "solid") if (Re.length === 1) {
+			let Me = _(ee, Object.assign(Object.assign({}, Ne), {
 				disableMultiStroke: !0,
-				roughness: n.roughness ? n.roughness + n.fillShapeRoughnessGain : 0
+				roughness: Ne.roughness ? Ne.roughness + Ne.fillShapeRoughnessGain : 0
 			}));
-			r.push({
+			Pe.push({
 				type: "fillPath",
-				ops: this._mergedShape(t.ops)
+				ops: this._mergedShape(Me.ops)
 			});
-		} else r.push(M(s, n));
-		else r.push(N(s, n));
-		return a && (o ? s.forEach(((e) => {
-			r.push(T(e, !1, n));
-		})) : r.push(c)), this._d("path", r, n);
-	}
-	opsToPath(e, t) {
-		let n = "";
-		for (let r of e.ops) {
-			let e = typeof t == "number" && t >= 0 ? r.data.map(((e) => +e.toFixed(t))) : r.data;
-			switch (r.op) {
+		} else Pe.push(I(Re, Ne));
+		else Pe.push(C(Re, Ne));
+		return Ie && (Le ? Re.forEach(((ee) => {
+			Pe.push(S(ee, !1, Ne));
+		})) : Pe.push(ze)), this._d("path", Pe, Ne);
+	}
+	opsToPath(ee, Me) {
+		let Ne = "";
+		for (let Pe of ee.ops) {
+			let ee = typeof Me == "number" && Me >= 0 ? Pe.data.map(((ee) => +ee.toFixed(Me))) : Pe.data;
+			switch (Pe.op) {
 				case "move":
-					n += `M${e[0]} ${e[1]} `;
+					Ne += `M${ee[0]} ${ee[1]} `;
 					break;
 				case "bcurveTo":
-					n += `C${e[0]} ${e[1]}, ${e[2]} ${e[3]}, ${e[4]} ${e[5]} `;
+					Ne += `C${ee[0]} ${ee[1]}, ${ee[2]} ${ee[3]}, ${ee[4]} ${ee[5]} `;
 					break;
-				case "lineTo": n += `L${e[0]} ${e[1]} `;
+				case "lineTo": Ne += `L${ee[0]} ${ee[1]} `;
 			}
 		}
-		return n.trim();
+		return Ne.trim();
 	}
-	toPaths(e) {
-		let t = e.sets || [], n = e.options || this.defaultOptions, r = [];
-		for (let e of t) {
-			let t = null;
-			switch (e.type) {
+	toPaths(ee) {
+		let Me = ee.sets || [], Ne = ee.options || this.defaultOptions, Pe = [];
+		for (let ee of Me) {
+			let Me = null;
+			switch (ee.type) {
 				case "path":
-					t = {
-						d: this.opsToPath(e),
-						stroke: n.stroke,
-						strokeWidth: n.strokeWidth,
-						fill: Z
+					Me = {
+						d: this.opsToPath(ee),
+						stroke: Ne.stroke,
+						strokeWidth: Ne.strokeWidth,
+						fill: tt
 					};
 					break;
 				case "fillPath":
-					t = {
-						d: this.opsToPath(e),
-						stroke: Z,
+					Me = {
+						d: this.opsToPath(ee),
+						stroke: tt,
 						strokeWidth: 0,
-						fill: n.fill || Z
+						fill: Ne.fill || tt
 					};
 					break;
-				case "fillSketch": t = this.fillSketch(e, n);
+				case "fillSketch": Me = this.fillSketch(ee, Ne);
 			}
-			t && r.push(t);
+			Me && Pe.push(Me);
 		}
-		return r;
-	}
-	fillSketch(e, t) {
-		let n = t.fillWeight;
-		return n < 0 && (n = t.strokeWidth / 2), {
-			d: this.opsToPath(e),
-			stroke: t.fill || Z,
-			strokeWidth: n,
-			fill: Z
+		return Pe;
+	}
+	fillSketch(ee, Me) {
+		let Ne = Me.fillWeight;
+		return Ne < 0 && (Ne = Me.strokeWidth / 2), {
+			d: this.opsToPath(ee),
+			stroke: Me.fill || tt,
+			strokeWidth: Ne,
+			fill: tt
 		};
 	}
-	_mergedShape(e) {
-		return e.filter(((e, t) => t === 0 || e.op !== "move"));
+	_mergedShape(ee) {
+		return ee.filter(((ee, Me) => Me === 0 || ee.op !== "move"));
 	}
-}, re = class {
-	constructor(e, t) {
-		this.canvas = e, this.ctx = this.canvas.getContext("2d"), this.gen = new Q(t);
+}, st = class {
+	constructor(ee, Me) {
+		this.canvas = ee, this.ctx = this.canvas.getContext("2d"), this.gen = new et(Me);
 	}
-	draw(e) {
-		let t = e.sets || [], n = e.options || this.getDefaultOptions(), r = this.ctx, i = e.options.fixedDecimalPlaceDigits;
-		for (let a of t) switch (a.type) {
+	draw(ee) {
+		let Me = ee.sets || [], Ne = ee.options || this.getDefaultOptions(), Pe = this.ctx, Fe = ee.options.fixedDecimalPlaceDigits;
+		for (let Ie of Me) switch (Ie.type) {
 			case "path":
-				r.save(), r.strokeStyle = n.stroke === "none" ? "transparent" : n.stroke, r.lineWidth = n.strokeWidth, n.strokeLineDash && r.setLineDash(n.strokeLineDash), n.strokeLineDashOffset && (r.lineDashOffset = n.strokeLineDashOffset), this._drawToContext(r, a, i), r.restore();
+				Pe.save(), Pe.strokeStyle = Ne.stroke === "none" ? "transparent" : Ne.stroke, Pe.lineWidth = Ne.strokeWidth, Ne.strokeLineDash && Pe.setLineDash(Ne.strokeLineDash), Ne.strokeLineDashOffset && (Pe.lineDashOffset = Ne.strokeLineDashOffset), this._drawToContext(Pe, Ie, Fe), Pe.restore();
 				break;
 			case "fillPath": {
-				r.save(), r.fillStyle = n.fill || "";
-				let t = e.shape === "curve" || e.shape === "polygon" || e.shape === "path" ? "evenodd" : "nonzero";
-				this._drawToContext(r, a, i, t), r.restore();
+				Pe.save(), Pe.fillStyle = Ne.fill || "";
+				let Me = ee.shape === "curve" || ee.shape === "polygon" || ee.shape === "path" ? "evenodd" : "nonzero";
+				this._drawToContext(Pe, Ie, Fe, Me), Pe.restore();
 				break;
 			}
-			case "fillSketch": this.fillSketch(r, a, n);
+			case "fillSketch": this.fillSketch(Pe, Ie, Ne);
 		}
 	}
-	fillSketch(e, t, n) {
-		let r = n.fillWeight;
-		r < 0 && (r = n.strokeWidth / 2), e.save(), n.fillLineDash && e.setLineDash(n.fillLineDash), n.fillLineDashOffset && (e.lineDashOffset = n.fillLineDashOffset), e.strokeStyle = n.fill || "", e.lineWidth = r, this._drawToContext(e, t, n.fixedDecimalPlaceDigits), e.restore();
+	fillSketch(ee, Me, Ne) {
+		let Pe = Ne.fillWeight;
+		Pe < 0 && (Pe = Ne.strokeWidth / 2), ee.save(), Ne.fillLineDash && ee.setLineDash(Ne.fillLineDash), Ne.fillLineDashOffset && (ee.lineDashOffset = Ne.fillLineDashOffset), ee.strokeStyle = Ne.fill || "", ee.lineWidth = Pe, this._drawToContext(ee, Me, Ne.fixedDecimalPlaceDigits), ee.restore();
 	}
-	_drawToContext(e, t, n, r = "nonzero") {
-		e.beginPath();
-		for (let r of t.ops) {
-			let t = typeof n == "number" && n >= 0 ? r.data.map(((e) => +e.toFixed(n))) : r.data;
-			switch (r.op) {
+	_drawToContext(ee, Me, Ne, Pe = "nonzero") {
+		ee.beginPath();
+		for (let Pe of Me.ops) {
+			let Me = typeof Ne == "number" && Ne >= 0 ? Pe.data.map(((ee) => +ee.toFixed(Ne))) : Pe.data;
+			switch (Pe.op) {
 				case "move":
-					e.moveTo(t[0], t[1]);
+					ee.moveTo(Me[0], Me[1]);
 					break;
 				case "bcurveTo":
-					e.bezierCurveTo(t[0], t[1], t[2], t[3], t[4], t[5]);
+					ee.bezierCurveTo(Me[0], Me[1], Me[2], Me[3], Me[4], Me[5]);
 					break;
-				case "lineTo": e.lineTo(t[0], t[1]);
+				case "lineTo": ee.lineTo(Me[0], Me[1]);
 			}
 		}
-		t.type === "fillPath" ? e.fill(r) : e.stroke();
+		Me.type === "fillPath" ? ee.fill(Pe) : ee.stroke();
 	}
 	get generator() {
 		return this.gen;
@@ -1234,68 +1233,68 @@ var Z = "none", Q = class {
 	getDefaultOptions() {
 		return this.gen.defaultOptions;
 	}
-	line(e, t, n, r, i) {
-		let a = this.gen.line(e, t, n, r, i);
-		return this.draw(a), a;
+	line(ee, Me, Ne, Pe, Fe) {
+		let Ie = this.gen.line(ee, Me, Ne, Pe, Fe);
+		return this.draw(Ie), Ie;
 	}
-	rectangle(e, t, n, r, i) {
-		let a = this.gen.rectangle(e, t, n, r, i);
-		return this.draw(a), a;
+	rectangle(ee, Me, Ne, Pe, Fe) {
+		let Ie = this.gen.rectangle(ee, Me, Ne, Pe, Fe);
+		return this.draw(Ie), Ie;
 	}
-	ellipse(e, t, n, r, i) {
-		let a = this.gen.ellipse(e, t, n, r, i);
-		return this.draw(a), a;
+	ellipse(ee, Me, Ne, Pe, Fe) {
+		let Ie = this.gen.ellipse(ee, Me, Ne, Pe, Fe);
+		return this.draw(Ie), Ie;
 	}
-	circle(e, t, n, r) {
-		let i = this.gen.circle(e, t, n, r);
-		return this.draw(i), i;
+	circle(ee, Me, Ne, Pe) {
+		let Fe = this.gen.circle(ee, Me, Ne, Pe);
+		return this.draw(Fe), Fe;
 	}
-	linearPath(e, t) {
-		let n = this.gen.linearPath(e, t);
-		return this.draw(n), n;
+	linearPath(ee, Me) {
+		let Ne = this.gen.linearPath(ee, Me);
+		return this.draw(Ne), Ne;
 	}
-	polygon(e, t) {
-		let n = this.gen.polygon(e, t);
-		return this.draw(n), n;
+	polygon(ee, Me) {
+		let Ne = this.gen.polygon(ee, Me);
+		return this.draw(Ne), Ne;
 	}
-	arc(e, t, n, r, i, a, o = !1, s) {
-		let c = this.gen.arc(e, t, n, r, i, a, o, s);
-		return this.draw(c), c;
+	arc(ee, Me, Ne, Pe, Fe, Ie, Le = !1, Re) {
+		let ze = this.gen.arc(ee, Me, Ne, Pe, Fe, Ie, Le, Re);
+		return this.draw(ze), ze;
 	}
-	curve(e, t) {
-		let n = this.gen.curve(e, t);
-		return this.draw(n), n;
+	curve(ee, Me) {
+		let Ne = this.gen.curve(ee, Me);
+		return this.draw(Ne), Ne;
 	}
-	path(e, t) {
-		let n = this.gen.path(e, t);
-		return this.draw(n), n;
+	path(ee, Me) {
+		let Ne = this.gen.path(ee, Me);
+		return this.draw(Ne), Ne;
 	}
-}, $ = "http://www.w3.org/2000/svg", ie = class {
-	constructor(e, t) {
-		this.svg = e, this.gen = new Q(t);
+}, nt = "http://www.w3.org/2000/svg", ot = class {
+	constructor(ee, Me) {
+		this.svg = ee, this.gen = new et(Me);
 	}
-	draw(e) {
-		let t = e.sets || [], n = e.options || this.getDefaultOptions(), r = this.svg.ownerDocument || window.document, i = r.createElementNS($, "g"), a = e.options.fixedDecimalPlaceDigits;
-		for (let o of t) {
-			let t = null;
-			switch (o.type) {
+	draw(ee) {
+		let Me = ee.sets || [], Ne = ee.options || this.getDefaultOptions(), Pe = this.svg.ownerDocument || window.document, Fe = Pe.createElementNS(nt, "g"), Ie = ee.options.fixedDecimalPlaceDigits;
+		for (let Le of Me) {
+			let Me = null;
+			switch (Le.type) {
 				case "path":
-					t = r.createElementNS($, "path"), t.setAttribute("d", this.opsToPath(o, a)), t.setAttribute("stroke", n.stroke), t.setAttribute("stroke-width", n.strokeWidth + ""), t.setAttribute("fill", "none"), n.strokeLineDash && t.setAttribute("stroke-dasharray", n.strokeLineDash.join(" ").trim()), n.strokeLineDashOffset && t.setAttribute("stroke-dashoffset", `${n.strokeLineDashOffset}`);
+					Me = Pe.createElementNS(nt, "path"), Me.setAttribute("d", this.opsToPath(Le, Ie)), Me.setAttribute("stroke", Ne.stroke), Me.setAttribute("stroke-width", Ne.strokeWidth + ""), Me.setAttribute("fill", "none"), Ne.strokeLineDash && Me.setAttribute("stroke-dasharray", Ne.strokeLineDash.join(" ").trim()), Ne.strokeLineDashOffset && Me.setAttribute("stroke-dashoffset", `${Ne.strokeLineDashOffset}`);
 					break;
 				case "fillPath":
-					t = r.createElementNS($, "path"), t.setAttribute("d", this.opsToPath(o, a)), t.setAttribute("stroke", "none"), t.setAttribute("stroke-width", "0"), t.setAttribute("fill", n.fill || ""), e.shape !== "curve" && e.shape !== "polygon" || t.setAttribute("fill-rule", "evenodd");
+					Me = Pe.createElementNS(nt, "path"), Me.setAttribute("d", this.opsToPath(Le, Ie)), Me.setAttribute("stroke", "none"), Me.setAttribute("stroke-width", "0"), Me.setAttribute("fill", Ne.fill || ""), ee.shape !== "curve" && ee.shape !== "polygon" || Me.setAttribute("fill-rule", "evenodd");
 					break;
-				case "fillSketch": t = this.fillSketch(r, o, n);
+				case "fillSketch": Me = this.fillSketch(Pe, Le, Ne);
 			}
-			t && i.appendChild(t);
+			Me && Fe.appendChild(Me);
 		}
-		return i;
+		return Fe;
 	}
-	fillSketch(e, t, n) {
-		let r = n.fillWeight;
-		r < 0 && (r = n.strokeWidth / 2);
-		let i = e.createElementNS($, "path");
-		return i.setAttribute("d", this.opsToPath(t, n.fixedDecimalPlaceDigits)), i.setAttribute("stroke", n.fill || ""), i.setAttribute("stroke-width", r + ""), i.setAttribute("fill", "none"), n.fillLineDash && i.setAttribute("stroke-dasharray", n.fillLineDash.join(" ").trim()), n.fillLineDashOffset && i.setAttribute("stroke-dashoffset", `${n.fillLineDashOffset}`), i;
+	fillSketch(ee, Me, Ne) {
+		let Pe = Ne.fillWeight;
+		Pe < 0 && (Pe = Ne.strokeWidth / 2);
+		let Fe = ee.createElementNS(nt, "path");
+		return Fe.setAttribute("d", this.opsToPath(Me, Ne.fixedDecimalPlaceDigits)), Fe.setAttribute("stroke", Ne.fill || ""), Fe.setAttribute("stroke-width", Pe + ""), Fe.setAttribute("fill", "none"), Ne.fillLineDash && Fe.setAttribute("stroke-dasharray", Ne.fillLineDash.join(" ").trim()), Ne.fillLineDashOffset && Fe.setAttribute("stroke-dashoffset", `${Ne.fillLineDashOffset}`), Fe;
 	}
 	get generator() {
 		return this.gen;
@@ -1303,50 +1302,49 @@ var Z = "none", Q = class {
 	getDefaultOptions() {
 		return this.gen.defaultOptions;
 	}
-	opsToPath(e, t) {
-		return this.gen.opsToPath(e, t);
+	opsToPath(ee, Me) {
+		return this.gen.opsToPath(ee, Me);
 	}
-	line(e, t, n, r, i) {
-		let a = this.gen.line(e, t, n, r, i);
-		return this.draw(a);
+	line(ee, Me, Ne, Pe, Fe) {
+		let Ie = this.gen.line(ee, Me, Ne, Pe, Fe);
+		return this.draw(Ie);
 	}
-	rectangle(e, t, n, r, i) {
-		let a = this.gen.rectangle(e, t, n, r, i);
-		return this.draw(a);
+	rectangle(ee, Me, Ne, Pe, Fe) {
+		let Ie = this.gen.rectangle(ee, Me, Ne, Pe, Fe);
+		return this.draw(Ie);
 	}
-	ellipse(e, t, n, r, i) {
-		let a = this.gen.ellipse(e, t, n, r, i);
-		return this.draw(a);
+	ellipse(ee, Me, Ne, Pe, Fe) {
+		let Ie = this.gen.ellipse(ee, Me, Ne, Pe, Fe);
+		return this.draw(Ie);
 	}
-	circle(e, t, n, r) {
-		let i = this.gen.circle(e, t, n, r);
-		return this.draw(i);
+	circle(ee, Me, Ne, Pe) {
+		let Fe = this.gen.circle(ee, Me, Ne, Pe);
+		return this.draw(Fe);
 	}
-	linearPath(e, t) {
-		let n = this.gen.linearPath(e, t);
-		return this.draw(n);
+	linearPath(ee, Me) {
+		let Ne = this.gen.linearPath(ee, Me);
+		return this.draw(Ne);
 	}
-	polygon(e, t) {
-		let n = this.gen.polygon(e, t);
-		return this.draw(n);
+	polygon(ee, Me) {
+		let Ne = this.gen.polygon(ee, Me);
+		return this.draw(Ne);
 	}
-	arc(e, t, n, r, i, a, o = !1, s) {
-		let c = this.gen.arc(e, t, n, r, i, a, o, s);
-		return this.draw(c);
+	arc(ee, Me, Ne, Pe, Fe, Ie, Le = !1, Re) {
+		let ze = this.gen.arc(ee, Me, Ne, Pe, Fe, Ie, Le, Re);
+		return this.draw(ze);
 	}
-	curve(e, t) {
-		let n = this.gen.curve(e, t);
-		return this.draw(n);
+	curve(ee, Me) {
+		let Ne = this.gen.curve(ee, Me);
+		return this.draw(Ne);
 	}
-	path(e, t) {
-		let n = this.gen.path(e, t);
-		return this.draw(n);
+	path(ee, Me) {
+		let Ne = this.gen.path(ee, Me);
+		return this.draw(Ne);
 	}
-}, ae = {
-	canvas: (e, t) => new re(e, t),
-	svg: (e, t) => new ie(e, t),
-	generator: (e) => new Q(e),
-	newSeed: () => Q.newSeed()
+}, at = {
+	canvas: (ee, Me) => new st(ee, Me),
+	svg: (ee, Me) => new ot(ee, Me),
+	generator: (ee) => new et(ee),
+	newSeed: () => et.newSeed()
 };
-//#endregion
-export { ae as at };
+export { at };