@mintlify/components 0.4.16 → 1.0.0

package/dist/node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bundled/rough.esm.js

@@ -0,0 +1,994 @@
+function X(a, e, s) {
+  if (a && a.length) {
+    const [t, n] = e, o = Math.PI / 180 * s, r = Math.cos(o), h = Math.sin(o);
+    for (const i of a) {
+      const [l, c] = i;
+      i[0] = (l - t) * r - (c - n) * h + t, i[1] = (l - t) * h + (c - n) * r + n;
+    }
+  }
+}
+function Ot(a, e) {
+  return a[0] === e[0] && a[1] === e[1];
+}
+function Lt(a, e, s, t = 1) {
+  const n = s, o = Math.max(e, 0.1), r = a[0] && a[0][0] && typeof a[0][0] == "number" ? [a] : a, h = [0, 0];
+  if (n) for (const l of r) X(l, h, n);
+  const i = (function(l, c, d) {
+    const p = [];
+    for (const M of l) {
+      const m = [...M];
+      Ot(m[0], m[m.length - 1]) || m.push([m[0][0], m[0][1]]), m.length > 2 && p.push(m);
+    }
+    const u = [];
+    c = Math.max(c, 0.1);
+    const f = [];
+    for (const M of p) for (let m = 0; m < M.length - 1; m++) {
+      const P = M[m], x = M[m + 1];
+      if (P[1] !== x[1]) {
+        const w = Math.min(P[1], x[1]);
+        f.push({ ymin: w, ymax: Math.max(P[1], x[1]), x: w === P[1] ? P[0] : x[0], islope: (x[0] - P[0]) / (x[1] - P[1]) });
+      }
+    }
+    if (f.sort(((M, m) => M.ymin < m.ymin ? -1 : M.ymin > m.ymin ? 1 : M.x < m.x ? -1 : M.x > m.x ? 1 : M.ymax === m.ymax ? 0 : (M.ymax - m.ymax) / Math.abs(M.ymax - m.ymax))), !f.length) return u;
+    let g = [], k = f[0].ymin, b = 0;
+    for (; g.length || f.length; ) {
+      if (f.length) {
+        let M = -1;
+        for (let m = 0; m < f.length && !(f[m].ymin > k); m++) M = m;
+        f.splice(0, M + 1).forEach(((m) => {
+          g.push({ s: k, edge: m });
+        }));
+      }
+      if (g = g.filter(((M) => !(M.edge.ymax <= k))), g.sort(((M, m) => M.edge.x === m.edge.x ? 0 : (M.edge.x - m.edge.x) / Math.abs(M.edge.x - m.edge.x))), (d !== 1 || b % c == 0) && g.length > 1) for (let M = 0; M < g.length; M += 2) {
+        const m = M + 1;
+        if (m >= g.length) break;
+        const P = g[M].edge, x = g[m].edge;
+        u.push([[Math.round(P.x), k], [Math.round(x.x), k]]);
+      }
+      k += d, g.forEach(((M) => {
+        M.edge.x = M.edge.x + d * M.edge.islope;
+      })), b++;
+    }
+    return u;
+  })(r, o, t);
+  if (n) {
+    for (const l of r) X(l, h, -n);
+    (function(l, c, d) {
+      const p = [];
+      l.forEach(((u) => p.push(...u))), X(p, c, d);
+    })(i, h, -n);
+  }
+  return i;
+}
+function j(a, e) {
+  var s;
+  const t = e.hachureAngle + 90;
+  let n = e.hachureGap;
+  n < 0 && (n = 4 * e.strokeWidth), n = Math.round(Math.max(n, 0.1));
+  let o = 1;
+  return e.roughness >= 1 && (((s = e.randomizer) === null || s === void 0 ? void 0 : s.next()) || Math.random()) > 0.7 && (o = n), Lt(a, n, t, o || 1);
+}
+class ht {
+  constructor(e) {
+    this.helper = e;
+  }
+  fillPolygons(e, s) {
+    return this._fillPolygons(e, s);
+  }
+  _fillPolygons(e, s) {
+    const t = j(e, s);
+    return { type: "fillSketch", ops: this.renderLines(t, s) };
+  }
+  renderLines(e, s) {
+    const t = [];
+    for (const n of e) t.push(...this.helper.doubleLineOps(n[0][0], n[0][1], n[1][0], n[1][1], s));
+    return t;
+  }
+}
+function U(a) {
+  const e = a[0], s = a[1];
+  return Math.sqrt(Math.pow(e[0] - s[0], 2) + Math.pow(e[1] - s[1], 2));
+}
+class Tt extends ht {
+  fillPolygons(e, s) {
+    let t = s.hachureGap;
+    t < 0 && (t = 4 * s.strokeWidth), t = Math.max(t, 0.1);
+    const n = j(e, Object.assign({}, s, { hachureGap: t })), o = Math.PI / 180 * s.hachureAngle, r = [], h = 0.5 * t * Math.cos(o), i = 0.5 * t * Math.sin(o);
+    for (const [l, c] of n) U([l, c]) && r.push([[l[0] - h, l[1] + i], [...c]], [[l[0] + h, l[1] - i], [...c]]);
+    return { type: "fillSketch", ops: this.renderLines(r, s) };
+  }
+}
+class Dt extends ht {
+  fillPolygons(e, s) {
+    const t = this._fillPolygons(e, s), n = Object.assign({}, s, { hachureAngle: s.hachureAngle + 90 }), o = this._fillPolygons(e, n);
+    return t.ops = t.ops.concat(o.ops), t;
+  }
+}
+class At {
+  constructor(e) {
+    this.helper = e;
+  }
+  fillPolygons(e, s) {
+    const t = j(e, s = Object.assign({}, s, { hachureAngle: 0 }));
+    return this.dotsOnLines(t, s);
+  }
+  dotsOnLines(e, s) {
+    const t = [];
+    let n = s.hachureGap;
+    n < 0 && (n = 4 * s.strokeWidth), n = Math.max(n, 0.1);
+    let o = s.fillWeight;
+    o < 0 && (o = s.strokeWidth / 2);
+    const r = n / 4;
+    for (const h of e) {
+      const i = U(h), l = i / n, c = Math.ceil(l) - 1, d = i - c * n, p = (h[0][0] + h[1][0]) / 2 - n / 4, u = Math.min(h[0][1], h[1][1]);
+      for (let f = 0; f < c; f++) {
+        const g = u + d + f * n, k = p - r + 2 * Math.random() * r, b = g - r + 2 * Math.random() * r, M = this.helper.ellipse(k, b, o, o, s);
+        t.push(...M.ops);
+      }
+    }
+    return { type: "fillSketch", ops: t };
+  }
+}
+class _t {
+  constructor(e) {
+    this.helper = e;
+  }
+  fillPolygons(e, s) {
+    const t = j(e, s);
+    return { type: "fillSketch", ops: this.dashedLine(t, s) };
+  }
+  dashedLine(e, s) {
+    const t = s.dashOffset < 0 ? s.hachureGap < 0 ? 4 * s.strokeWidth : s.hachureGap : s.dashOffset, n = s.dashGap < 0 ? s.hachureGap < 0 ? 4 * s.strokeWidth : s.hachureGap : s.dashGap, o = [];
+    return e.forEach(((r) => {
+      const h = U(r), i = Math.floor(h / (t + n)), l = (h + n - i * (t + n)) / 2;
+      let c = r[0], d = r[1];
+      c[0] > d[0] && (c = r[1], d = r[0]);
+      const p = Math.atan((d[1] - c[1]) / (d[0] - c[0]));
+      for (let u = 0; u < i; u++) {
+        const f = u * (t + n), g = f + t, k = [c[0] + f * Math.cos(p) + l * Math.cos(p), c[1] + f * Math.sin(p) + l * Math.sin(p)], b = [c[0] + g * Math.cos(p) + l * Math.cos(p), c[1] + g * Math.sin(p) + l * Math.sin(p)];
+        o.push(...this.helper.doubleLineOps(k[0], k[1], b[0], b[1], s));
+      }
+    })), o;
+  }
+}
+class It {
+  constructor(e) {
+    this.helper = e;
+  }
+  fillPolygons(e, s) {
+    const t = s.hachureGap < 0 ? 4 * s.strokeWidth : s.hachureGap, n = s.zigzagOffset < 0 ? t : s.zigzagOffset, o = j(e, s = Object.assign({}, s, { hachureGap: t + n }));
+    return { type: "fillSketch", ops: this.zigzagLines(o, n, s) };
+  }
+  zigzagLines(e, s, t) {
+    const n = [];
+    return e.forEach(((o) => {
+      const r = U(o), h = Math.round(r / (2 * s));
+      let i = o[0], l = o[1];
+      i[0] > l[0] && (i = o[1], l = o[0]);
+      const c = Math.atan((l[1] - i[1]) / (l[0] - i[0]));
+      for (let d = 0; d < h; d++) {
+        const p = 2 * d * s, u = 2 * (d + 1) * s, f = Math.sqrt(2 * Math.pow(s, 2)), g = [i[0] + p * Math.cos(c), i[1] + p * Math.sin(c)], k = [i[0] + u * Math.cos(c), i[1] + u * Math.sin(c)], b = [g[0] + f * Math.cos(c + Math.PI / 4), g[1] + f * Math.sin(c + Math.PI / 4)];
+        n.push(...this.helper.doubleLineOps(g[0], g[1], b[0], b[1], t), ...this.helper.doubleLineOps(b[0], b[1], k[0], k[1], t));
+      }
+    })), n;
+  }
+}
+const S = {};
+class Ct {
+  constructor(e) {
+    this.seed = e;
+  }
+  next() {
+    return this.seed ? (2 ** 31 - 1 & (this.seed = Math.imul(48271, this.seed))) / 2 ** 31 : Math.random();
+  }
+}
+const zt = 0, Y = 1, lt = 2, F = { 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 tt(a, e) {
+  return a.type === e;
+}
+function rt(a) {
+  const e = [], s = (function(r) {
+    const h = new Array();
+    for (; r !== ""; ) if (r.match(/^([ \t\r\n,]+)/)) r = r.substr(RegExp.$1.length);
+    else if (r.match(/^([aAcChHlLmMqQsStTvVzZ])/)) h[h.length] = { type: zt, text: RegExp.$1 }, r = r.substr(RegExp.$1.length);
+    else {
+      if (!r.match(/^(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)/)) return [];
+      h[h.length] = { type: Y, text: `${parseFloat(RegExp.$1)}` }, r = r.substr(RegExp.$1.length);
+    }
+    return h[h.length] = { type: lt, text: "" }, h;
+  })(a);
+  let t = "BOD", n = 0, o = s[n];
+  for (; !tt(o, lt); ) {
+    let r = 0;
+    const h = [];
+    if (t === "BOD") {
+      if (o.text !== "M" && o.text !== "m") return rt("M0,0" + a);
+      n++, r = F[o.text], t = o.text;
+    } else tt(o, Y) ? r = F[t] : (n++, r = F[o.text], t = o.text);
+    if (!(n + r < s.length)) throw new Error("Path data ended short");
+    for (let i = n; i < n + r; i++) {
+      const l = s[i];
+      if (!tt(l, Y)) throw new Error("Param not a number: " + t + "," + l.text);
+      h[h.length] = +l.text;
+    }
+    if (typeof F[t] != "number") throw new Error("Bad segment: " + t);
+    {
+      const i = { key: t, data: h };
+      e.push(i), n += r, o = s[n], t === "M" && (t = "L"), t === "m" && (t = "l");
+    }
+  }
+  return e;
+}
+function bt(a) {
+  let e = 0, s = 0, t = 0, n = 0;
+  const o = [];
+  for (const { key: r, data: h } of a) switch (r) {
+    case "M":
+      o.push({ key: "M", data: [...h] }), [e, s] = h, [t, n] = h;
+      break;
+    case "m":
+      e += h[0], s += h[1], o.push({ key: "M", data: [e, s] }), t = e, n = s;
+      break;
+    case "L":
+      o.push({ key: "L", data: [...h] }), [e, s] = h;
+      break;
+    case "l":
+      e += h[0], s += h[1], o.push({ key: "L", data: [e, s] });
+      break;
+    case "C":
+      o.push({ key: "C", data: [...h] }), e = h[4], s = h[5];
+      break;
+    case "c": {
+      const i = h.map(((l, c) => c % 2 ? l + s : l + e));
+      o.push({ key: "C", data: i }), e = i[4], s = i[5];
+      break;
+    }
+    case "Q":
+      o.push({ key: "Q", data: [...h] }), e = h[2], s = h[3];
+      break;
+    case "q": {
+      const i = h.map(((l, c) => c % 2 ? l + s : l + e));
+      o.push({ key: "Q", data: i }), e = i[2], s = i[3];
+      break;
+    }
+    case "A":
+      o.push({ key: "A", data: [...h] }), e = h[5], s = h[6];
+      break;
+    case "a":
+      e += h[5], s += h[6], o.push({ key: "A", data: [h[0], h[1], h[2], h[3], h[4], e, s] });
+      break;
+    case "H":
+      o.push({ key: "H", data: [...h] }), e = h[0];
+      break;
+    case "h":
+      e += h[0], o.push({ key: "H", data: [e] });
+      break;
+    case "V":
+      o.push({ key: "V", data: [...h] }), s = h[0];
+      break;
+    case "v":
+      s += h[0], o.push({ key: "V", data: [s] });
+      break;
+    case "S":
+      o.push({ key: "S", data: [...h] }), e = h[2], s = h[3];
+      break;
+    case "s": {
+      const i = h.map(((l, c) => c % 2 ? l + s : l + e));
+      o.push({ key: "S", data: i }), e = i[2], s = i[3];
+      break;
+    }
+    case "T":
+      o.push({ key: "T", data: [...h] }), e = h[0], s = h[1];
+      break;
+    case "t":
+      e += h[0], s += h[1], o.push({ key: "T", data: [e, s] });
+      break;
+    case "Z":
+    case "z":
+      o.push({ key: "Z", data: [] }), e = t, s = n;
+  }
+  return o;
+}
+function yt(a) {
+  const e = [];
+  let s = "", t = 0, n = 0, o = 0, r = 0, h = 0, i = 0;
+  for (const { key: l, data: c } of a) {
+    switch (l) {
+      case "M":
+        e.push({ key: "M", data: [...c] }), [t, n] = c, [o, r] = c;
+        break;
+      case "C":
+        e.push({ key: "C", data: [...c] }), t = c[4], n = c[5], h = c[2], i = c[3];
+        break;
+      case "L":
+        e.push({ key: "L", data: [...c] }), [t, n] = c;
+        break;
+      case "H":
+        t = c[0], e.push({ key: "L", data: [t, n] });
+        break;
+      case "V":
+        n = c[0], e.push({ key: "L", data: [t, n] });
+        break;
+      case "S": {
+        let d = 0, p = 0;
+        s === "C" || s === "S" ? (d = t + (t - h), p = n + (n - i)) : (d = t, p = n), e.push({ key: "C", data: [d, p, ...c] }), h = c[0], i = c[1], t = c[2], n = c[3];
+        break;
+      }
+      case "T": {
+        const [d, p] = c;
+        let u = 0, f = 0;
+        s === "Q" || s === "T" ? (u = t + (t - h), f = n + (n - i)) : (u = t, f = n);
+        const g = t + 2 * (u - t) / 3, k = n + 2 * (f - n) / 3, b = d + 2 * (u - d) / 3, M = p + 2 * (f - p) / 3;
+        e.push({ key: "C", data: [g, k, b, M, d, p] }), h = u, i = f, t = d, n = p;
+        break;
+      }
+      case "Q": {
+        const [d, p, u, f] = c, g = t + 2 * (d - t) / 3, k = n + 2 * (p - n) / 3, b = u + 2 * (d - u) / 3, M = f + 2 * (p - f) / 3;
+        e.push({ key: "C", data: [g, k, b, M, u, f] }), h = d, i = p, t = u, n = f;
+        break;
+      }
+      case "A": {
+        const d = Math.abs(c[0]), p = Math.abs(c[1]), u = c[2], f = c[3], g = c[4], k = c[5], b = c[6];
+        d === 0 || p === 0 ? (e.push({ key: "C", data: [t, n, k, b, k, b] }), t = k, n = b) : (t !== k || n !== b) && (mt(t, n, k, b, d, p, u, f, g).forEach((function(M) {
+          e.push({ key: "C", data: M });
+        })), t = k, n = b);
+        break;
+      }
+      case "Z":
+        e.push({ key: "Z", data: [] }), t = o, n = r;
+    }
+    s = l;
+  }
+  return e;
+}
+function $(a, e, s) {
+  return [a * Math.cos(s) - e * Math.sin(s), a * Math.sin(s) + e * Math.cos(s)];
+}
+function mt(a, e, s, t, n, o, r, h, i, l) {
+  const c = (d = r, Math.PI * d / 180);
+  var d;
+  let p = [], u = 0, f = 0, g = 0, k = 0;
+  if (l) [u, f, g, k] = l;
+  else {
+    [a, e] = $(a, e, -c), [s, t] = $(s, t, -c);
+    const T = (a - s) / 2, v = (e - t) / 2;
+    let _ = T * T / (n * n) + v * v / (o * o);
+    _ > 1 && (_ = Math.sqrt(_), n *= _, o *= _);
+    const W = n * n, E = o * o, vt = W * E - W * v * v - E * T * T, St = W * v * v + E * T * T, ct = (h === i ? -1 : 1) * Math.sqrt(Math.abs(vt / St));
+    g = ct * n * v / o + (a + s) / 2, k = ct * -o * T / n + (e + t) / 2, u = Math.asin(parseFloat(((e - k) / o).toFixed(9))), f = Math.asin(parseFloat(((t - k) / o).toFixed(9))), a < g && (u = Math.PI - u), s < g && (f = Math.PI - f), u < 0 && (u = 2 * Math.PI + u), f < 0 && (f = 2 * Math.PI + f), i && u > f && (u -= 2 * Math.PI), !i && f > u && (f -= 2 * Math.PI);
+  }
+  let b = f - u;
+  if (Math.abs(b) > 120 * Math.PI / 180) {
+    const T = f, v = s, _ = t;
+    f = i && f > u ? u + 120 * Math.PI / 180 * 1 : u + 120 * Math.PI / 180 * -1, p = mt(s = g + n * Math.cos(f), t = k + o * Math.sin(f), v, _, n, o, r, 0, i, [f, T, g, k]);
+  }
+  b = f - u;
+  const M = Math.cos(u), m = Math.sin(u), P = Math.cos(f), x = Math.sin(f), w = Math.tan(b / 4), L = 4 / 3 * n * w, A = 4 / 3 * o * w, q = [a, e], D = [a + L * m, e - A * M], C = [s + L * x, t - A * P], it = [s, t];
+  if (D[0] = 2 * q[0] - D[0], D[1] = 2 * q[1] - D[1], l) return [D, C, it].concat(p);
+  {
+    p = [D, C, it].concat(p);
+    const T = [];
+    for (let v = 0; v < p.length; v += 3) {
+      const _ = $(p[v][0], p[v][1], c), W = $(p[v + 1][0], p[v + 1][1], c), E = $(p[v + 2][0], p[v + 2][1], c);
+      T.push([_[0], _[1], W[0], W[1], E[0], E[1]]);
+    }
+    return T;
+  }
+}
+const Wt = { randOffset: function(a, e) {
+  return y(a, e);
+}, randOffsetWithRange: function(a, e, s) {
+  return N(a, e, s);
+}, ellipse: function(a, e, s, t, n) {
+  const o = xt(s, t, n);
+  return nt(a, e, n, o).opset;
+}, doubleLineOps: function(a, e, s, t, n) {
+  return I(a, e, s, t, n, !0);
+} };
+function wt(a, e, s, t, n) {
+  return { type: "path", ops: I(a, e, s, t, n) };
+}
+function Q(a, e, s) {
+  const t = (a || []).length;
+  if (t > 2) {
+    const n = [];
+    for (let o = 0; o < t - 1; o++) n.push(...I(a[o][0], a[o][1], a[o + 1][0], a[o + 1][1], s));
+    return e && n.push(...I(a[t - 1][0], a[t - 1][1], a[0][0], a[0][1], s)), { type: "path", ops: n };
+  }
+  return t === 2 ? wt(a[0][0], a[0][1], a[1][0], a[1][1], s) : { type: "path", ops: [] };
+}
+function Et(a, e, s, t, n) {
+  return (function(o, r) {
+    return Q(o, !0, r);
+  })([[a, e], [a + s, e], [a + s, e + t], [a, e + t]], n);
+}
+function ut(a, e) {
+  if (a.length) {
+    const s = typeof a[0][0] == "number" ? [a] : a, t = V(s[0], 1 * (1 + 0.2 * e.roughness), e), n = e.disableMultiStroke ? [] : V(s[0], 1.5 * (1 + 0.22 * e.roughness), dt(e));
+    for (let o = 1; o < s.length; o++) {
+      const r = s[o];
+      if (r.length) {
+        const h = V(r, 1 * (1 + 0.2 * e.roughness), e), i = e.disableMultiStroke ? [] : V(r, 1.5 * (1 + 0.22 * e.roughness), dt(e));
+        for (const l of h) l.op !== "move" && t.push(l);
+        for (const l of i) l.op !== "move" && n.push(l);
+      }
+    }
+    return { type: "path", ops: t.concat(n) };
+  }
+  return { type: "path", ops: [] };
+}
+function xt(a, e, s) {
+  const t = Math.sqrt(2 * Math.PI * Math.sqrt((Math.pow(a / 2, 2) + Math.pow(e / 2, 2)) / 2)), n = Math.ceil(Math.max(s.curveStepCount, s.curveStepCount / Math.sqrt(200) * t)), o = 2 * Math.PI / n;
+  let r = Math.abs(a / 2), h = Math.abs(e / 2);
+  const i = 1 - s.curveFitting;
+  return r += y(r * i, s), h += y(h * i, s), { increment: o, rx: r, ry: h };
+}
+function nt(a, e, s, t) {
+  const [n, o] = gt(t.increment, a, e, t.rx, t.ry, 1, t.increment * N(0.1, N(0.4, 1, s), s), s);
+  let r = B(n, null, s);
+  if (!s.disableMultiStroke && s.roughness !== 0) {
+    const [h] = gt(t.increment, a, e, t.rx, t.ry, 1.5, 0, s), i = B(h, null, s);
+    r = r.concat(i);
+  }
+  return { estimatedPoints: o, opset: { type: "path", ops: r } };
+}
+function pt(a, e, s, t, n, o, r, h, i) {
+  const l = a, c = e;
+  let d = Math.abs(s / 2), p = Math.abs(t / 2);
+  d += y(0.01 * d, i), p += y(0.01 * p, i);
+  let u = n, f = o;
+  for (; u < 0; ) u += 2 * Math.PI, f += 2 * Math.PI;
+  f - u > 2 * Math.PI && (u = 0, f = 2 * Math.PI);
+  const g = 2 * Math.PI / i.curveStepCount, k = Math.min(g / 2, (f - u) / 2), b = Mt(k, l, c, d, p, u, f, 1, i);
+  if (!i.disableMultiStroke) {
+    const M = Mt(k, l, c, d, p, u, f, 1.5, i);
+    b.push(...M);
+  }
+  return r && (h ? b.push(...I(l, c, l + d * Math.cos(u), c + p * Math.sin(u), i), ...I(l, c, l + d * Math.cos(f), c + p * Math.sin(f), i)) : b.push({ op: "lineTo", data: [l, c] }, { op: "lineTo", data: [l + d * Math.cos(u), c + p * Math.sin(u)] })), { type: "path", ops: b };
+}
+function ft(a, e) {
+  const s = yt(bt(rt(a))), t = [];
+  let n = [0, 0], o = [0, 0];
+  for (const { key: r, data: h } of s) switch (r) {
+    case "M":
+      o = [h[0], h[1]], n = [h[0], h[1]];
+      break;
+    case "L":
+      t.push(...I(o[0], o[1], h[0], h[1], e)), o = [h[0], h[1]];
+      break;
+    case "C": {
+      const [i, l, c, d, p, u] = h;
+      t.push(...Gt(i, l, c, d, p, u, o, e)), o = [p, u];
+      break;
+    }
+    case "Z":
+      t.push(...I(o[0], o[1], n[0], n[1], e)), o = [n[0], n[1]];
+  }
+  return { type: "path", ops: t };
+}
+function et(a, e) {
+  const s = [];
+  for (const t of a) if (t.length) {
+    const n = e.maxRandomnessOffset || 0, o = t.length;
+    if (o > 2) {
+      s.push({ op: "move", data: [t[0][0] + y(n, e), t[0][1] + y(n, e)] });
+      for (let r = 1; r < o; r++) s.push({ op: "lineTo", data: [t[r][0] + y(n, e), t[r][1] + y(n, e)] });
+    }
+  }
+  return { type: "fillPath", ops: s };
+}
+function G(a, e) {
+  return (function(s, t) {
+    let n = s.fillStyle || "hachure";
+    if (!S[n]) switch (n) {
+      case "zigzag":
+        S[n] || (S[n] = new Tt(t));
+        break;
+      case "cross-hatch":
+        S[n] || (S[n] = new Dt(t));
+        break;
+      case "dots":
+        S[n] || (S[n] = new At(t));
+        break;
+      case "dashed":
+        S[n] || (S[n] = new _t(t));
+        break;
+      case "zigzag-line":
+        S[n] || (S[n] = new It(t));
+        break;
+      default:
+        n = "hachure", S[n] || (S[n] = new ht(t));
+    }
+    return S[n];
+  })(e, Wt).fillPolygons(a, e);
+}
+function dt(a) {
+  const e = Object.assign({}, a);
+  return e.randomizer = void 0, a.seed && (e.seed = a.seed + 1), e;
+}
+function Pt(a) {
+  return a.randomizer || (a.randomizer = new Ct(a.seed || 0)), a.randomizer.next();
+}
+function N(a, e, s, t = 1) {
+  return s.roughness * t * (Pt(s) * (e - a) + a);
+}
+function y(a, e, s = 1) {
+  return N(-a, a, e, s);
+}
+function I(a, e, s, t, n, o = !1) {
+  const r = o ? n.disableMultiStrokeFill : n.disableMultiStroke, h = at(a, e, s, t, n, !0, !1);
+  if (r) return h;
+  const i = at(a, e, s, t, n, !0, !0);
+  return h.concat(i);
+}
+function at(a, e, s, t, n, o, r) {
+  const h = Math.pow(a - s, 2) + Math.pow(e - t, 2), i = Math.sqrt(h);
+  let l = 1;
+  l = i < 200 ? 1 : i > 500 ? 0.4 : -16668e-7 * i + 1.233334;
+  let c = n.maxRandomnessOffset || 0;
+  c * c * 100 > h && (c = i / 10);
+  const d = c / 2, p = 0.2 + 0.2 * Pt(n);
+  let u = n.bowing * n.maxRandomnessOffset * (t - e) / 200, f = n.bowing * n.maxRandomnessOffset * (a - s) / 200;
+  u = y(u, n, l), f = y(f, n, l);
+  const g = [], k = () => y(d, n, l), b = () => y(c, n, l), M = n.preserveVertices;
+  return r ? g.push({ op: "move", data: [a + (M ? 0 : k()), e + (M ? 0 : k())] }) : g.push({ op: "move", data: [a + (M ? 0 : y(c, n, l)), e + (M ? 0 : y(c, n, l))] }), r ? g.push({ op: "bcurveTo", data: [u + a + (s - a) * p + k(), f + e + (t - e) * p + k(), u + a + 2 * (s - a) * p + k(), f + e + 2 * (t - e) * p + k(), s + (M ? 0 : k()), t + (M ? 0 : k())] }) : g.push({ op: "bcurveTo", data: [u + a + (s - a) * p + b(), f + e + (t - e) * p + b(), u + a + 2 * (s - a) * p + b(), f + e + 2 * (t - e) * p + b(), s + (M ? 0 : b()), t + (M ? 0 : b())] }), g;
+}
+function V(a, e, s) {
+  if (!a.length) return [];
+  const t = [];
+  t.push([a[0][0] + y(e, s), a[0][1] + y(e, s)]), t.push([a[0][0] + y(e, s), a[0][1] + y(e, s)]);
+  for (let n = 1; n < a.length; n++) t.push([a[n][0] + y(e, s), a[n][1] + y(e, s)]), n === a.length - 1 && t.push([a[n][0] + y(e, s), a[n][1] + y(e, s)]);
+  return B(t, null, s);
+}
+function B(a, e, s) {
+  const t = a.length, n = [];
+  if (t > 3) {
+    const o = [], r = 1 - s.curveTightness;
+    n.push({ op: "move", data: [a[1][0], a[1][1]] });
+    for (let h = 1; h + 2 < t; h++) {
+      const i = a[h];
+      o[0] = [i[0], i[1]], o[1] = [i[0] + (r * a[h + 1][0] - r * a[h - 1][0]) / 6, i[1] + (r * a[h + 1][1] - r * a[h - 1][1]) / 6], o[2] = [a[h + 1][0] + (r * a[h][0] - r * a[h + 2][0]) / 6, a[h + 1][1] + (r * a[h][1] - r * a[h + 2][1]) / 6], o[3] = [a[h + 1][0], a[h + 1][1]], n.push({ op: "bcurveTo", data: [o[1][0], o[1][1], o[2][0], o[2][1], o[3][0], o[3][1]] });
+    }
+  } else t === 3 ? (n.push({ op: "move", data: [a[1][0], a[1][1]] }), n.push({ op: "bcurveTo", data: [a[1][0], a[1][1], a[2][0], a[2][1], a[2][0], a[2][1]] })) : t === 2 && n.push(...at(a[0][0], a[0][1], a[1][0], a[1][1], s, !0, !0));
+  return n;
+}
+function gt(a, e, s, t, n, o, r, h) {
+  const i = [], l = [];
+  if (h.roughness === 0) {
+    a /= 4, l.push([e + t * Math.cos(-a), s + n * Math.sin(-a)]);
+    for (let c = 0; c <= 2 * Math.PI; c += a) {
+      const d = [e + t * Math.cos(c), s + n * Math.sin(c)];
+      i.push(d), l.push(d);
+    }
+    l.push([e + t * Math.cos(0), s + n * Math.sin(0)]), l.push([e + t * Math.cos(a), s + n * Math.sin(a)]);
+  } else {
+    const c = y(0.5, h) - Math.PI / 2;
+    l.push([y(o, h) + e + 0.9 * t * Math.cos(c - a), y(o, h) + s + 0.9 * n * Math.sin(c - a)]);
+    const d = 2 * Math.PI + c - 0.01;
+    for (let p = c; p < d; p += a) {
+      const u = [y(o, h) + e + t * Math.cos(p), y(o, h) + s + n * Math.sin(p)];
+      i.push(u), l.push(u);
+    }
+    l.push([y(o, h) + e + t * Math.cos(c + 2 * Math.PI + 0.5 * r), y(o, h) + s + n * Math.sin(c + 2 * Math.PI + 0.5 * r)]), l.push([y(o, h) + e + 0.98 * t * Math.cos(c + r), y(o, h) + s + 0.98 * n * Math.sin(c + r)]), l.push([y(o, h) + e + 0.9 * t * Math.cos(c + 0.5 * r), y(o, h) + s + 0.9 * n * Math.sin(c + 0.5 * r)]);
+  }
+  return [l, i];
+}
+function Mt(a, e, s, t, n, o, r, h, i) {
+  const l = o + y(0.1, i), c = [];
+  c.push([y(h, i) + e + 0.9 * t * Math.cos(l - a), y(h, i) + s + 0.9 * n * Math.sin(l - a)]);
+  for (let d = l; d <= r; d += a) c.push([y(h, i) + e + t * Math.cos(d), y(h, i) + s + n * Math.sin(d)]);
+  return c.push([e + t * Math.cos(r), s + n * Math.sin(r)]), c.push([e + t * Math.cos(r), s + n * Math.sin(r)]), B(c, null, i);
+}
+function Gt(a, e, s, t, n, o, r, h) {
+  const i = [], l = [h.maxRandomnessOffset || 1, (h.maxRandomnessOffset || 1) + 0.3];
+  let c = [0, 0];
+  const d = h.disableMultiStroke ? 1 : 2, p = h.preserveVertices;
+  for (let u = 0; u < d; u++) u === 0 ? i.push({ op: "move", data: [r[0], r[1]] }) : i.push({ op: "move", data: [r[0] + (p ? 0 : y(l[0], h)), r[1] + (p ? 0 : y(l[0], h))] }), c = p ? [n, o] : [n + y(l[u], h), o + y(l[u], h)], i.push({ op: "bcurveTo", data: [a + y(l[u], h), e + y(l[u], h), s + y(l[u], h), t + y(l[u], h), c[0], c[1]] });
+  return i;
+}
+function R(a) {
+  return [...a];
+}
+function kt(a, e = 0) {
+  const s = a.length;
+  if (s < 3) throw new Error("A curve must have at least three points.");
+  const t = [];
+  if (s === 3) t.push(R(a[0]), R(a[1]), R(a[2]), R(a[2]));
+  else {
+    const n = [];
+    n.push(a[0], a[0]);
+    for (let h = 1; h < a.length; h++) n.push(a[h]), h === a.length - 1 && n.push(a[h]);
+    const o = [], r = 1 - e;
+    t.push(R(n[0]));
+    for (let h = 1; h + 2 < n.length; h++) {
+      const i = n[h];
+      o[0] = [i[0], i[1]], o[1] = [i[0] + (r * n[h + 1][0] - r * n[h - 1][0]) / 6, i[1] + (r * n[h + 1][1] - r * n[h - 1][1]) / 6], o[2] = [n[h + 1][0] + (r * n[h][0] - r * n[h + 2][0]) / 6, n[h + 1][1] + (r * n[h][1] - r * n[h + 2][1]) / 6], o[3] = [n[h + 1][0], n[h + 1][1]], t.push(o[1], o[2], o[3]);
+    }
+  }
+  return t;
+}
+function H(a, e) {
+  return Math.pow(a[0] - e[0], 2) + Math.pow(a[1] - e[1], 2);
+}
+function $t(a, e, s) {
+  const t = H(e, s);
+  if (t === 0) return H(a, e);
+  let n = ((a[0] - e[0]) * (s[0] - e[0]) + (a[1] - e[1]) * (s[1] - e[1])) / t;
+  return n = Math.max(0, Math.min(1, n)), H(a, z(e, s, n));
+}
+function z(a, e, s) {
+  return [a[0] + (e[0] - a[0]) * s, a[1] + (e[1] - a[1]) * s];
+}
+function ot(a, e, s, t) {
+  const n = t || [];
+  if ((function(h, i) {
+    const l = h[i + 0], c = h[i + 1], d = h[i + 2], p = h[i + 3];
+    let u = 3 * c[0] - 2 * l[0] - p[0];
+    u *= u;
+    let f = 3 * c[1] - 2 * l[1] - p[1];
+    f *= f;
+    let g = 3 * d[0] - 2 * p[0] - l[0];
+    g *= g;
+    let k = 3 * d[1] - 2 * p[1] - l[1];
+    return k *= k, u < g && (u = g), f < k && (f = k), u + f;
+  })(a, e) < s) {
+    const h = a[e + 0];
+    n.length ? (o = n[n.length - 1], r = h, Math.sqrt(H(o, r)) > 1 && n.push(h)) : n.push(h), n.push(a[e + 3]);
+  } else {
+    const i = a[e + 0], l = a[e + 1], c = a[e + 2], d = a[e + 3], p = z(i, l, 0.5), u = z(l, c, 0.5), f = z(c, d, 0.5), g = z(p, u, 0.5), k = z(u, f, 0.5), b = z(g, k, 0.5);
+    ot([i, p, g, b], 0, s, n), ot([b, k, f, d], 0, s, n);
+  }
+  var o, r;
+  return n;
+}
+function Rt(a, e) {
+  return J(a, 0, a.length, e);
+}
+function J(a, e, s, t, n) {
+  const o = n || [], r = a[e], h = a[s - 1];
+  let i = 0, l = 1;
+  for (let c = e + 1; c < s - 1; ++c) {
+    const d = $t(a[c], r, h);
+    d > i && (i = d, l = c);
+  }
+  return Math.sqrt(i) > t ? (J(a, e, l + 1, t, o), J(a, l, s, t, o)) : (o.length || o.push(r), o.push(h)), o;
+}
+function st(a, e = 0.15, s) {
+  const t = [], n = (a.length - 1) / 3;
+  for (let o = 0; o < n; o++)
+    ot(a, 3 * o, e, t);
+  return s && s > 0 ? J(t, 0, t.length, s) : t;
+}
+const O = "none";
+class K {
+  constructor(e) {
+    this.defaultOptions = { maxRandomnessOffset: 2, roughness: 1, bowing: 1, stroke: "#000", strokeWidth: 1, curveTightness: 0, curveFitting: 0.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: 0.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, s, t) {
+    return { shape: e, sets: s || [], options: t || this.defaultOptions };
+  }
+  line(e, s, t, n, o) {
+    const r = this._o(o);
+    return this._d("line", [wt(e, s, t, n, r)], r);
+  }
+  rectangle(e, s, t, n, o) {
+    const r = this._o(o), h = [], i = Et(e, s, t, n, r);
+    if (r.fill) {
+      const l = [[e, s], [e + t, s], [e + t, s + n], [e, s + n]];
+      r.fillStyle === "solid" ? h.push(et([l], r)) : h.push(G([l], r));
+    }
+    return r.stroke !== O && h.push(i), this._d("rectangle", h, r);
+  }
+  ellipse(e, s, t, n, o) {
+    const r = this._o(o), h = [], i = xt(t, n, r), l = nt(e, s, r, i);
+    if (r.fill) if (r.fillStyle === "solid") {
+      const c = nt(e, s, r, i).opset;
+      c.type = "fillPath", h.push(c);
+    } else h.push(G([l.estimatedPoints], r));
+    return r.stroke !== O && h.push(l.opset), this._d("ellipse", h, r);
+  }
+  circle(e, s, t, n) {
+    const o = this.ellipse(e, s, t, t, n);
+    return o.shape = "circle", o;
+  }
+  linearPath(e, s) {
+    const t = this._o(s);
+    return this._d("linearPath", [Q(e, !1, t)], t);
+  }
+  arc(e, s, t, n, o, r, h = !1, i) {
+    const l = this._o(i), c = [], d = pt(e, s, t, n, o, r, h, !0, l);
+    if (h && l.fill) if (l.fillStyle === "solid") {
+      const p = Object.assign({}, l);
+      p.disableMultiStroke = !0;
+      const u = pt(e, s, t, n, o, r, !0, !1, p);
+      u.type = "fillPath", c.push(u);
+    } else c.push((function(p, u, f, g, k, b, M) {
+      const m = p, P = u;
+      let x = Math.abs(f / 2), w = Math.abs(g / 2);
+      x += y(0.01 * x, M), w += y(0.01 * w, M);
+      let L = k, A = b;
+      for (; L < 0; ) L += 2 * Math.PI, A += 2 * Math.PI;
+      A - L > 2 * Math.PI && (L = 0, A = 2 * Math.PI);
+      const q = (A - L) / M.curveStepCount, D = [];
+      for (let C = L; C <= A; C += q) D.push([m + x * Math.cos(C), P + w * Math.sin(C)]);
+      return D.push([m + x * Math.cos(A), P + w * Math.sin(A)]), D.push([m, P]), G([D], M);
+    })(e, s, t, n, o, r, l));
+    return l.stroke !== O && c.push(d), this._d("arc", c, l);
+  }
+  curve(e, s) {
+    const t = this._o(s), n = [], o = ut(e, t);
+    if (t.fill && t.fill !== O) if (t.fillStyle === "solid") {
+      const r = ut(e, Object.assign(Object.assign({}, t), { disableMultiStroke: !0, roughness: t.roughness ? t.roughness + t.fillShapeRoughnessGain : 0 }));
+      n.push({ type: "fillPath", ops: this._mergedShape(r.ops) });
+    } else {
+      const r = [], h = e;
+      if (h.length) {
+        const i = typeof h[0][0] == "number" ? [h] : h;
+        for (const l of i) l.length < 3 ? r.push(...l) : l.length === 3 ? r.push(...st(kt([l[0], l[0], l[1], l[2]]), 10, (1 + t.roughness) / 2)) : r.push(...st(kt(l), 10, (1 + t.roughness) / 2));
+      }
+      r.length && n.push(G([r], t));
+    }
+    return t.stroke !== O && n.push(o), this._d("curve", n, t);
+  }
+  polygon(e, s) {
+    const t = this._o(s), n = [], o = Q(e, !0, t);
+    return t.fill && (t.fillStyle === "solid" ? n.push(et([e], t)) : n.push(G([e], t))), t.stroke !== O && n.push(o), this._d("polygon", n, t);
+  }
+  path(e, s) {
+    const t = this._o(s), n = [];
+    if (!e) return this._d("path", n, t);
+    e = (e || "").replace(/\n/g, " ").replace(/(-\s)/g, "-").replace("/(ss)/g", " ");
+    const o = t.fill && t.fill !== "transparent" && t.fill !== O, r = t.stroke !== O, h = !!(t.simplification && t.simplification < 1), i = (function(c, d, p) {
+      const u = yt(bt(rt(c))), f = [];
+      let g = [], k = [0, 0], b = [];
+      const M = () => {
+        b.length >= 4 && g.push(...st(b, d)), b = [];
+      }, m = () => {
+        M(), g.length && (f.push(g), g = []);
+      };
+      for (const { key: x, data: w } of u) switch (x) {
+        case "M":
+          m(), k = [w[0], w[1]], g.push(k);
+          break;
+        case "L":
+          M(), g.push([w[0], w[1]]);
+          break;
+        case "C":
+          if (!b.length) {
+            const L = g.length ? g[g.length - 1] : k;
+            b.push([L[0], L[1]]);
+          }
+          b.push([w[0], w[1]]), b.push([w[2], w[3]]), b.push([w[4], w[5]]);
+          break;
+        case "Z":
+          M(), g.push([k[0], k[1]]);
+      }
+      if (m(), !p) return f;
+      const P = [];
+      for (const x of f) {
+        const w = Rt(x, p);
+        w.length && P.push(w);
+      }
+      return P;
+    })(e, 1, h ? 4 - 4 * (t.simplification || 1) : (1 + t.roughness) / 2), l = ft(e, t);
+    if (o) if (t.fillStyle === "solid") if (i.length === 1) {
+      const c = ft(e, Object.assign(Object.assign({}, t), { disableMultiStroke: !0, roughness: t.roughness ? t.roughness + t.fillShapeRoughnessGain : 0 }));
+      n.push({ type: "fillPath", ops: this._mergedShape(c.ops) });
+    } else n.push(et(i, t));
+    else n.push(G(i, t));
+    return r && (h ? i.forEach(((c) => {
+      n.push(Q(c, !1, t));
+    })) : n.push(l)), this._d("path", n, t);
+  }
+  opsToPath(e, s) {
+    let t = "";
+    for (const n of e.ops) {
+      const o = typeof s == "number" && s >= 0 ? n.data.map(((r) => +r.toFixed(s))) : n.data;
+      switch (n.op) {
+        case "move":
+          t += `M${o[0]} ${o[1]} `;
+          break;
+        case "bcurveTo":
+          t += `C${o[0]} ${o[1]}, ${o[2]} ${o[3]}, ${o[4]} ${o[5]} `;
+          break;
+        case "lineTo":
+          t += `L${o[0]} ${o[1]} `;
+      }
+    }
+    return t.trim();
+  }
+  toPaths(e) {
+    const s = e.sets || [], t = e.options || this.defaultOptions, n = [];
+    for (const o of s) {
+      let r = null;
+      switch (o.type) {
+        case "path":
+          r = { d: this.opsToPath(o), stroke: t.stroke, strokeWidth: t.strokeWidth, fill: O };
+          break;
+        case "fillPath":
+          r = { d: this.opsToPath(o), stroke: O, strokeWidth: 0, fill: t.fill || O };
+          break;
+        case "fillSketch":
+          r = this.fillSketch(o, t);
+      }
+      r && n.push(r);
+    }
+    return n;
+  }
+  fillSketch(e, s) {
+    let t = s.fillWeight;
+    return t < 0 && (t = s.strokeWidth / 2), { d: this.opsToPath(e), stroke: s.fill || O, strokeWidth: t, fill: O };
+  }
+  _mergedShape(e) {
+    return e.filter(((s, t) => t === 0 || s.op !== "move"));
+  }
+}
+class jt {
+  constructor(e, s) {
+    this.canvas = e, this.ctx = this.canvas.getContext("2d"), this.gen = new K(s);
+  }
+  draw(e) {
+    const s = e.sets || [], t = e.options || this.getDefaultOptions(), n = this.ctx, o = e.options.fixedDecimalPlaceDigits;
+    for (const r of s) switch (r.type) {
+      case "path":
+        n.save(), n.strokeStyle = t.stroke === "none" ? "transparent" : t.stroke, n.lineWidth = t.strokeWidth, t.strokeLineDash && n.setLineDash(t.strokeLineDash), t.strokeLineDashOffset && (n.lineDashOffset = t.strokeLineDashOffset), this._drawToContext(n, r, o), n.restore();
+        break;
+      case "fillPath": {
+        n.save(), n.fillStyle = t.fill || "";
+        const h = e.shape === "curve" || e.shape === "polygon" || e.shape === "path" ? "evenodd" : "nonzero";
+        this._drawToContext(n, r, o, h), n.restore();
+        break;
+      }
+      case "fillSketch":
+        this.fillSketch(n, r, t);
+    }
+  }
+  fillSketch(e, s, t) {
+    let n = t.fillWeight;
+    n < 0 && (n = t.strokeWidth / 2), e.save(), t.fillLineDash && e.setLineDash(t.fillLineDash), t.fillLineDashOffset && (e.lineDashOffset = t.fillLineDashOffset), e.strokeStyle = t.fill || "", e.lineWidth = n, this._drawToContext(e, s, t.fixedDecimalPlaceDigits), e.restore();
+  }
+  _drawToContext(e, s, t, n = "nonzero") {
+    e.beginPath();
+    for (const o of s.ops) {
+      const r = typeof t == "number" && t >= 0 ? o.data.map(((h) => +h.toFixed(t))) : o.data;
+      switch (o.op) {
+        case "move":
+          e.moveTo(r[0], r[1]);
+          break;
+        case "bcurveTo":
+          e.bezierCurveTo(r[0], r[1], r[2], r[3], r[4], r[5]);
+          break;
+        case "lineTo":
+          e.lineTo(r[0], r[1]);
+      }
+    }
+    s.type === "fillPath" ? e.fill(n) : e.stroke();
+  }
+  get generator() {
+    return this.gen;
+  }
+  getDefaultOptions() {
+    return this.gen.defaultOptions;
+  }
+  line(e, s, t, n, o) {
+    const r = this.gen.line(e, s, t, n, o);
+    return this.draw(r), r;
+  }
+  rectangle(e, s, t, n, o) {
+    const r = this.gen.rectangle(e, s, t, n, o);
+    return this.draw(r), r;
+  }
+  ellipse(e, s, t, n, o) {
+    const r = this.gen.ellipse(e, s, t, n, o);
+    return this.draw(r), r;
+  }
+  circle(e, s, t, n) {
+    const o = this.gen.circle(e, s, t, n);
+    return this.draw(o), o;
+  }
+  linearPath(e, s) {
+    const t = this.gen.linearPath(e, s);
+    return this.draw(t), t;
+  }
+  polygon(e, s) {
+    const t = this.gen.polygon(e, s);
+    return this.draw(t), t;
+  }
+  arc(e, s, t, n, o, r, h = !1, i) {
+    const l = this.gen.arc(e, s, t, n, o, r, h, i);
+    return this.draw(l), l;
+  }
+  curve(e, s) {
+    const t = this.gen.curve(e, s);
+    return this.draw(t), t;
+  }
+  path(e, s) {
+    const t = this.gen.path(e, s);
+    return this.draw(t), t;
+  }
+}
+const Z = "http://www.w3.org/2000/svg";
+class qt {
+  constructor(e, s) {
+    this.svg = e, this.gen = new K(s);
+  }
+  draw(e) {
+    const s = e.sets || [], t = e.options || this.getDefaultOptions(), n = this.svg.ownerDocument || window.document, o = n.createElementNS(Z, "g"), r = e.options.fixedDecimalPlaceDigits;
+    for (const h of s) {
+      let i = null;
+      switch (h.type) {
+        case "path":
+          i = n.createElementNS(Z, "path"), i.setAttribute("d", this.opsToPath(h, r)), i.setAttribute("stroke", t.stroke), i.setAttribute("stroke-width", t.strokeWidth + ""), i.setAttribute("fill", "none"), t.strokeLineDash && i.setAttribute("stroke-dasharray", t.strokeLineDash.join(" ").trim()), t.strokeLineDashOffset && i.setAttribute("stroke-dashoffset", `${t.strokeLineDashOffset}`);
+          break;
+        case "fillPath":
+          i = n.createElementNS(Z, "path"), i.setAttribute("d", this.opsToPath(h, r)), i.setAttribute("stroke", "none"), i.setAttribute("stroke-width", "0"), i.setAttribute("fill", t.fill || ""), e.shape !== "curve" && e.shape !== "polygon" || i.setAttribute("fill-rule", "evenodd");
+          break;
+        case "fillSketch":
+          i = this.fillSketch(n, h, t);
+      }
+      i && o.appendChild(i);
+    }
+    return o;
+  }
+  fillSketch(e, s, t) {
+    let n = t.fillWeight;
+    n < 0 && (n = t.strokeWidth / 2);
+    const o = e.createElementNS(Z, "path");
+    return o.setAttribute("d", this.opsToPath(s, t.fixedDecimalPlaceDigits)), o.setAttribute("stroke", t.fill || ""), o.setAttribute("stroke-width", n + ""), o.setAttribute("fill", "none"), t.fillLineDash && o.setAttribute("stroke-dasharray", t.fillLineDash.join(" ").trim()), t.fillLineDashOffset && o.setAttribute("stroke-dashoffset", `${t.fillLineDashOffset}`), o;
+  }
+  get generator() {
+    return this.gen;
+  }
+  getDefaultOptions() {
+    return this.gen.defaultOptions;
+  }
+  opsToPath(e, s) {
+    return this.gen.opsToPath(e, s);
+  }
+  line(e, s, t, n, o) {
+    const r = this.gen.line(e, s, t, n, o);
+    return this.draw(r);
+  }
+  rectangle(e, s, t, n, o) {
+    const r = this.gen.rectangle(e, s, t, n, o);
+    return this.draw(r);
+  }
+  ellipse(e, s, t, n, o) {
+    const r = this.gen.ellipse(e, s, t, n, o);
+    return this.draw(r);
+  }
+  circle(e, s, t, n) {
+    const o = this.gen.circle(e, s, t, n);
+    return this.draw(o);
+  }
+  linearPath(e, s) {
+    const t = this.gen.linearPath(e, s);
+    return this.draw(t);
+  }
+  polygon(e, s) {
+    const t = this.gen.polygon(e, s);
+    return this.draw(t);
+  }
+  arc(e, s, t, n, o, r, h = !1, i) {
+    const l = this.gen.arc(e, s, t, n, o, r, h, i);
+    return this.draw(l);
+  }
+  curve(e, s) {
+    const t = this.gen.curve(e, s);
+    return this.draw(t);
+  }
+  path(e, s) {
+    const t = this.gen.path(e, s);
+    return this.draw(t);
+  }
+}
+var Ft = { canvas: (a, e) => new jt(a, e), svg: (a, e) => new qt(a, e), generator: (a) => new K(a), newSeed: () => K.newSeed() };
+export {
+  Ft as default
+};