@countermeasure-platform/web-components 0.2.0

package/dist/rough.esm-CJL_eUW6.js

@@ -0,0 +1,1354 @@
+//#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(e, t) {
+	return e[0] === t[0] && e[1] === t[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);
+		}
+		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])
+				});
+			}
+		}
+		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 (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]]);
+			}
+			c += r, s.forEach(((e) => {
+				e.edge.x = e.edge.x + r * e.edge.islope;
+			})), l++;
+		}
+		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;
+}
+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);
+}
+var i = class {
+	constructor(e) {
+		this.helper = e;
+	}
+	fillPolygons(e, t) {
+		return this._fillPolygons(e, t);
+	}
+	_fillPolygons(e, t) {
+		let n = r(e, t);
+		return {
+			type: "fillSketch",
+			ops: this.renderLines(n, t)
+		};
+	}
+	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;
+	}
+};
+function a(e) {
+	let t = e[0], n = e[1];
+	return Math.sqrt((t[0] - n[0]) ** 2 + (t[1] - n[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]]);
+		return {
+			type: "fillSketch",
+			ops: this.renderLines(s, t)
+		};
+	}
+}, 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);
+			}
+		}
+		return {
+			type: "fillSketch",
+			ops: n
+		};
+	}
+}, l = class {
+	constructor(e) {
+		this.helper = e;
+	}
+	fillPolygons(e, t) {
+		let n = r(e, t);
+		return {
+			type: "fillSketch",
+			ops: this.dashedLine(n, t)
+		};
+	}
+	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));
+			}
+		})), i;
+	}
+}, u = class {
+	constructor(e) {
+		this.helper = e;
+	}
+	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 }));
+		return {
+			type: "fillSketch",
+			ops: this.zigzagLines(a, i, t)
+		};
+	}
+	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));
+			}
+		})), r;
+	}
+}, d = {}, f = class {
+	constructor(e) {
+		this.seed = e;
+	}
+	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 = {
+	A: 7,
+	a: 7,
+	C: 6,
+	c: 6,
+	H: 1,
+	h: 1,
+	L: 2,
+	l: 2,
+	M: 2,
+	m: 2,
+	Q: 4,
+	q: 4,
+	S: 4,
+	s: 4,
+	T: 2,
+	t: 2,
+	V: 1,
+	v: 1,
+	Z: 0,
+	z: 0
+};
+function _(e, t) {
+	return e.type === t;
+}
+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,
+			text: RegExp.$1
+		}, e = e.substr(RegExp.$1.length);
+		else {
+			if (!e.match(/^(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)/)) return [];
+			t[t.length] = {
+				type: m,
+				text: `${parseFloat(RegExp.$1)}`
+			}, e = e.substr(RegExp.$1.length);
+		}
+		return t[t.length] = {
+			type: h,
+			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;
+		}
+		if (typeof g[r] != "number") throw Error("Bad segment: " + r);
+		{
+			let e = {
+				key: r,
+				data: s
+			};
+			t.push(e), i += o, a = n[i], r === "M" && (r = "L"), r === "m" && (r = "l");
+		}
+	}
+	return t;
+}
+function y(e) {
+	let t = 0, n = 0, r = 0, i = 0, a = [];
+	for (let { key: o, data: s } of e) switch (o) {
+		case "M":
+			a.push({
+				key: "M",
+				data: [...s]
+			}), [t, n] = s, [r, i] = s;
+			break;
+		case "m":
+			t += s[0], n += s[1], a.push({
+				key: "M",
+				data: [t, n]
+			}), r = t, i = n;
+			break;
+		case "L":
+			a.push({
+				key: "L",
+				data: [...s]
+			}), [t, n] = s;
+			break;
+		case "l":
+			t += s[0], n += s[1], a.push({
+				key: "L",
+				data: [t, n]
+			});
+			break;
+		case "C":
+			a.push({
+				key: "C",
+				data: [...s]
+			}), t = s[4], n = s[5];
+			break;
+		case "c": {
+			let e = s.map(((e, r) => r % 2 ? e + n : e + t));
+			a.push({
+				key: "C",
+				data: e
+			}), t = e[4], n = e[5];
+			break;
+		}
+		case "Q":
+			a.push({
+				key: "Q",
+				data: [...s]
+			}), t = s[2], n = s[3];
+			break;
+		case "q": {
+			let e = s.map(((e, r) => r % 2 ? e + n : e + t));
+			a.push({
+				key: "Q",
+				data: e
+			}), t = e[2], n = e[3];
+			break;
+		}
+		case "A":
+			a.push({
+				key: "A",
+				data: [...s]
+			}), t = s[5], n = s[6];
+			break;
+		case "a":
+			t += s[5], n += s[6], a.push({
+				key: "A",
+				data: [
+					s[0],
+					s[1],
+					s[2],
+					s[3],
+					s[4],
+					t,
+					n
+				]
+			});
+			break;
+		case "H":
+			a.push({
+				key: "H",
+				data: [...s]
+			}), t = s[0];
+			break;
+		case "h":
+			t += s[0], a.push({
+				key: "H",
+				data: [t]
+			});
+			break;
+		case "V":
+			a.push({
+				key: "V",
+				data: [...s]
+			}), n = s[0];
+			break;
+		case "v":
+			n += s[0], a.push({
+				key: "V",
+				data: [n]
+			});
+			break;
+		case "S":
+			a.push({
+				key: "S",
+				data: [...s]
+			}), t = s[2], n = s[3];
+			break;
+		case "s": {
+			let e = s.map(((e, r) => r % 2 ? e + n : e + t));
+			a.push({
+				key: "S",
+				data: e
+			}), t = e[2], n = e[3];
+			break;
+		}
+		case "T":
+			a.push({
+				key: "T",
+				data: [...s]
+			}), t = s[0], n = s[1];
+			break;
+		case "t":
+			t += s[0], n += s[1], a.push({
+				key: "T",
+				data: [t, n]
+			});
+			break;
+		case "Z":
+		case "z": a.push({
+			key: "Z",
+			data: []
+		}), t = r, n = i;
+	}
+	return a;
+}
+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) {
+			case "M":
+				t.push({
+					key: "M",
+					data: [...u]
+				}), [r, i] = u, [a, o] = u;
+				break;
+			case "C":
+				t.push({
+					key: "C",
+					data: [...u]
+				}), r = u[4], i = u[5], s = u[2], c = u[3];
+				break;
+			case "L":
+				t.push({
+					key: "L",
+					data: [...u]
+				}), [r, i] = u;
+				break;
+			case "H":
+				r = u[0], t.push({
+					key: "L",
+					data: [r, i]
+				});
+				break;
+			case "V":
+				i = u[0], t.push({
+					key: "L",
+					data: [r, i]
+				});
+				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({
+					key: "C",
+					data: [
+						e,
+						a,
+						...u
+					]
+				}), s = u[0], c = u[1], r = u[2], i = u[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({
+					key: "C",
+					data: [
+						d,
+						f,
+						p,
+						m,
+						e,
+						a
+					]
+				}), s = o, c = l, r = e, i = a;
+				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({
+					key: "C",
+					data: [
+						l,
+						d,
+						f,
+						p,
+						a,
+						o
+					]
+				}), s = e, c = n, r = a, i = o;
+				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({
+					key: "C",
+					data: [
+						r,
+						i,
+						c,
+						l,
+						c,
+						l
+					]
+				}), r = c, i = l) : (r !== c || i !== l) && (S(r, i, c, l, e, n, a, o, s).forEach((function(e) {
+					t.push({
+						key: "C",
+						data: e
+					});
+				})), r = c, i = l);
+				break;
+			}
+			case "Z": t.push({
+				key: "Z",
+				data: []
+			}), r = a, i = o;
+		}
+		n = l;
+	}
+	return t;
+}
+function x(e, t, n) {
+	return [e * Math.cos(n) - t * Math.sin(n), e * Math.sin(n) + t * Math.cos(n)];
+}
+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;
+	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
+		]);
+	}
+	_ = 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);
+	{
+		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]
+			]);
+		}
+		return e;
+	}
+}
+var C = {
+	randOffset: function(e, t) {
+		return L(e, t);
+	},
+	randOffsetWithRange: function(e, t, n) {
+		return I(e, t, n);
+	},
+	ellipse: function(e, t, n, r, i) {
+		return k(e, t, i, O(n, r, i)).opset;
+	},
+	doubleLineOps: function(e, t, n, r, i) {
+		return R(e, t, n, r, i, !0);
+	}
+};
+function w(e, t, n, r, i) {
+	return {
+		type: "path",
+		ops: R(e, t, n, r, i)
+	};
+}
+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)), {
+			type: "path",
+			ops: i
+		};
+	}
+	return r === 2 ? w(e[0][0], e[0][1], e[1][0], e[1][1], n) : {
+		type: "path",
+		ops: []
+	};
+}
+function E(e, t, n, r, i) {
+	return function(e, t) {
+		return T(e, !0, t);
+	}([
+		[e, t],
+		[e + n, t],
+		[e + n, t + r],
+		[e, t + r]
+	], i);
+}
+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);
+			}
+		}
+		return {
+			type: "path",
+			ops: r.concat(i)
+		};
+	}
+	return {
+		type: "path",
+		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 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);
+	}
+	return {
+		estimatedPoints: a,
+		opset: {
+			type: "path",
+			ops: o
+		}
+	};
+}
+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({
+		op: "lineTo",
+		data: [l, u]
+	}, {
+		op: "lineTo",
+		data: [l + d * Math.cos(p), u + f * Math.sin(p)]
+	})), {
+		type: "path",
+		ops: _
+	};
+}
+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) {
+		case "M":
+			a = [o[0], o[1]], i = [o[0], o[1]];
+			break;
+		case "L":
+			r.push(...R(a[0], a[1], o[0], o[1], t)), a = [o[0], o[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];
+			break;
+		}
+		case "Z": r.push(...R(a[0], a[1], i[0], i[1], t)), a = [i[0], i[1]];
+	}
+	return {
+		type: "path",
+		ops: r
+	};
+}
+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({
+				op: "move",
+				data: [r[0][0] + L(e, t), r[0][1] + L(e, t)]
+			});
+			for (let a = 1; a < i; a++) n.push({
+				op: "lineTo",
+				data: [r[a][0] + L(e, t), r[a][1] + L(e, t)]
+			});
+		}
+	}
+	return {
+		type: "fillPath",
+		ops: n
+	};
+}
+function N(e, t) {
+	return function(e, t) {
+		let n = e.fillStyle || "hachure";
+		if (!d[n]) switch (n) {
+			case "zigzag":
+				d[n] || (d[n] = new o(t));
+				break;
+			case "cross-hatch":
+				d[n] || (d[n] = new s(t));
+				break;
+			case "dots":
+				d[n] || (d[n] = new c(t));
+				break;
+			case "dashed":
+				d[n] || (d[n] = new l(t));
+				break;
+			case "zigzag-line":
+				d[n] || (d[n] = new u(t));
+				break;
+			default: n = "hachure", d[n] || (d[n] = new i(t));
+		}
+		return d[n];
+	}(t, C).fillPolygons(e, t);
+}
+function P(e) {
+	let t = Object.assign({}, e);
+	return t.randomizer = void 0, e.seed && (t.seed = e.seed + 1), t;
+}
+function F(e) {
+	return e.randomizer ||= new f(e.seed || 0), e.randomizer.next();
+}
+function I(e, t, n, r = 1) {
+	return n.roughness * r * (F(n) * (t - e) + e);
+}
+function L(e, t, n = 1) {
+	return I(-e, e, t, n);
+}
+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 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({
+		op: "move",
+		data: [e + (v ? 0 : g()), t + (v ? 0 : g())]
+	}) : h.push({
+		op: "move",
+		data: [e + (v ? 0 : L(u, i, l)), t + (v ? 0 : L(u, i, l))]
+	})), o ? h.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())
+		]
+	}) : h.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 : _())
+		]
+	}), h;
+}
+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 V(e, t, n) {
+	let r = e.length, i = [];
+	if (r > 3) {
+		let a = [], o = 1 - n.curveTightness;
+		i.push({
+			op: "move",
+			data: [e[1][0], e[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({
+				op: "bcurveTo",
+				data: [
+					a[1][0],
+					a[1][1],
+					a[2][0],
+					a[2][1],
+					a[3][0],
+					a[3][1]
+				]
+			});
+		}
+		if (t && t.length === 2) {
+			let e = n.maxRandomnessOffset;
+			i.push({
+				op: "lineTo",
+				data: [t[0] + L(e, n), t[1] + L(e, n)]
+			});
+		}
+	} else r === 3 ? (i.push({
+		op: "move",
+		data: [e[1][0], e[1][1]]
+	}), i.push({
+		op: "bcurveTo",
+		data: [
+			e[1][0],
+			e[1][1],
+			e[2][0],
+			e[2][1],
+			e[2][0],
+			e[2][1]
+		]
+	})) : r === 2 && i.push(...z(e[0][0], e[0][1], e[1][0], e[1][1], n, !0, !0));
+	return i;
+}
+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);
+		}
+		l.push([t + r * Math.cos(0), n + i * Math.sin(0)]), l.push([t + r * Math.cos(e), n + i * Math.sin(e)]);
+	} 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);
+		}
+		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)]);
+	}
+	return [l, c];
+}
+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 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({
+		op: "move",
+		data: [o[0], o[1]]
+	}) : c.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({
+		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]
+		]
+	});
+	return c;
+}
+function W(e) {
+	return [...e];
+}
+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]));
+	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]);
+		}
+	}
+	return r;
+}
+function K(e, t) {
+	return (e[0] - t[0]) ** 2 + (e[1] - t[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 q(e, t, n) {
+	return [e[0] + (t[0] - e[0]) * n, e[1] + (t[1] - e[1]) * n];
+}
+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]);
+	} 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;
+}
+function ne(e, t) {
+	return Y(e, 0, e.length, t);
+}
+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);
+	}
+	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;
+}
+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;
+}
+var Z = "none", Q = class {
+	constructor(e) {
+		this.defaultOptions = {
+			maxRandomnessOffset: 2,
+			roughness: 1,
+			bowing: 1,
+			stroke: "#000",
+			strokeWidth: 1,
+			curveTightness: 0,
+			curveFitting: .95,
+			curveStepCount: 9,
+			fillStyle: "hachure",
+			fillWeight: -1,
+			hachureAngle: -41,
+			hachureGap: -1,
+			dashOffset: -1,
+			dashGap: -1,
+			zigzagOffset: -1,
+			seed: 0,
+			disableMultiStroke: !1,
+			disableMultiStrokeFill: !1,
+			preserveVertices: !1,
+			fillShapeRoughnessGain: .8
+		}, this.config = e || {}, 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;
+	}
+	_d(e, t, n) {
+		return {
+			shape: e,
+			sets: t || [],
+			options: n || 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]
+			];
+			a.fillStyle === "solid" ? o.push(M([i], a)) : o.push(N([i], a));
+		}
+		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), {
+				disableMultiStroke: !0,
+				roughness: n.roughness ? n.roughness + n.fillShapeRoughnessGain : 0
+			}));
+			r.push({
+				type: "fillPath",
+				ops: this._mergedShape(t.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));
+			}
+			t.length && r.push(N([t], n));
+		}
+		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 = []);
+			};
+			for (let { key: e, data: t } of r) switch (e) {
+				case "M":
+					l(), o = [t[0], t[1]], a.push(o);
+					break;
+				case "L":
+					c(), a.push([t[0], t[1]]);
+					break;
+				case "C":
+					if (!s.length) {
+						let e = a.length ? a[a.length - 1] : o;
+						s.push([e[0], e[1]]);
+					}
+					s.push([t[0], t[1]]), s.push([t[2], t[3]]), s.push([t[4], t[5]]);
+					break;
+				case "Z": c(), a.push([o[0], o[1]]);
+			}
+			if (l(), !n) return i;
+			let u = [];
+			for (let e of i) {
+				let t = ne(e, n);
+				t.length && u.push(t);
+			}
+			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), {
+				disableMultiStroke: !0,
+				roughness: n.roughness ? n.roughness + n.fillShapeRoughnessGain : 0
+			}));
+			r.push({
+				type: "fillPath",
+				ops: this._mergedShape(t.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) {
+				case "move":
+					n += `M${e[0]} ${e[1]} `;
+					break;
+				case "bcurveTo":
+					n += `C${e[0]} ${e[1]}, ${e[2]} ${e[3]}, ${e[4]} ${e[5]} `;
+					break;
+				case "lineTo": n += `L${e[0]} ${e[1]} `;
+			}
+		}
+		return n.trim();
+	}
+	toPaths(e) {
+		let t = e.sets || [], n = e.options || this.defaultOptions, r = [];
+		for (let e of t) {
+			let t = null;
+			switch (e.type) {
+				case "path":
+					t = {
+						d: this.opsToPath(e),
+						stroke: n.stroke,
+						strokeWidth: n.strokeWidth,
+						fill: Z
+					};
+					break;
+				case "fillPath":
+					t = {
+						d: this.opsToPath(e),
+						stroke: Z,
+						strokeWidth: 0,
+						fill: n.fill || Z
+					};
+					break;
+				case "fillSketch": t = this.fillSketch(e, n);
+			}
+			t && r.push(t);
+		}
+		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
+		};
+	}
+	_mergedShape(e) {
+		return e.filter(((e, t) => t === 0 || e.op !== "move"));
+	}
+}, re = class {
+	constructor(e, t) {
+		this.canvas = e, this.ctx = this.canvas.getContext("2d"), this.gen = new Q(t);
+	}
+	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) {
+			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();
+				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();
+				break;
+			}
+			case "fillSketch": this.fillSketch(r, a, n);
+		}
+	}
+	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();
+	}
+	_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) {
+				case "move":
+					e.moveTo(t[0], t[1]);
+					break;
+				case "bcurveTo":
+					e.bezierCurveTo(t[0], t[1], t[2], t[3], t[4], t[5]);
+					break;
+				case "lineTo": e.lineTo(t[0], t[1]);
+			}
+		}
+		t.type === "fillPath" ? e.fill(r) : e.stroke();
+	}
+	get generator() {
+		return this.gen;
+	}
+	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;
+	}
+	rectangle(e, t, n, r, i) {
+		let a = this.gen.rectangle(e, t, n, r, i);
+		return this.draw(a), a;
+	}
+	ellipse(e, t, n, r, i) {
+		let a = this.gen.ellipse(e, t, n, r, i);
+		return this.draw(a), a;
+	}
+	circle(e, t, n, r) {
+		let i = this.gen.circle(e, t, n, r);
+		return this.draw(i), i;
+	}
+	linearPath(e, t) {
+		let n = this.gen.linearPath(e, t);
+		return this.draw(n), n;
+	}
+	polygon(e, t) {
+		let n = this.gen.polygon(e, t);
+		return this.draw(n), n;
+	}
+	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;
+	}
+	curve(e, t) {
+		let n = this.gen.curve(e, t);
+		return this.draw(n), n;
+	}
+	path(e, t) {
+		let n = this.gen.path(e, t);
+		return this.draw(n), n;
+	}
+}, $ = "http://www.w3.org/2000/svg", ie = class {
+	constructor(e, t) {
+		this.svg = e, this.gen = new Q(t);
+	}
+	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) {
+				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}`);
+					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");
+					break;
+				case "fillSketch": t = this.fillSketch(r, o, n);
+			}
+			t && i.appendChild(t);
+		}
+		return i;
+	}
+	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;
+	}
+	get generator() {
+		return this.gen;
+	}
+	getDefaultOptions() {
+		return this.gen.defaultOptions;
+	}
+	opsToPath(e, t) {
+		return this.gen.opsToPath(e, t);
+	}
+	line(e, t, n, r, i) {
+		let a = this.gen.line(e, t, n, r, i);
+		return this.draw(a);
+	}
+	rectangle(e, t, n, r, i) {
+		let a = this.gen.rectangle(e, t, n, r, i);
+		return this.draw(a);
+	}
+	ellipse(e, t, n, r, i) {
+		let a = this.gen.ellipse(e, t, n, r, i);
+		return this.draw(a);
+	}
+	circle(e, t, n, r) {
+		let i = this.gen.circle(e, t, n, r);
+		return this.draw(i);
+	}
+	linearPath(e, t) {
+		let n = this.gen.linearPath(e, t);
+		return this.draw(n);
+	}
+	polygon(e, t) {
+		let n = this.gen.polygon(e, t);
+		return this.draw(n);
+	}
+	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);
+	}
+	curve(e, t) {
+		let n = this.gen.curve(e, t);
+		return this.draw(n);
+	}
+	path(e, t) {
+		let n = this.gen.path(e, t);
+		return this.draw(n);
+	}
+}, ae = {
+	canvas: (e, t) => new re(e, t),
+	svg: (e, t) => new ie(e, t),
+	generator: (e) => new Q(e),
+	newSeed: () => Q.newSeed()
+};
+//#endregion
+export { ae as t };
+
+//# sourceMappingURL=rough.esm-CJL_eUW6.js.map