@marimo-team/islands 0.23.17-dev53 → 0.23.17-dev55

package/dist/rough.esm-lGyFQ0B-.js

@@ -0,0 +1,1363 @@
+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 Me2 of ee) {
+      let [ee2, Ne2] = Me2;
+      Me2[0] = (ee2 - Pe) * Le - (Ne2 - Fe) * Re + Pe, Me2[1] = (ee2 - Pe) * Re + (Ne2 - Fe) * Le + Fe;
+    }
+  }
+}
+function e(ee, Me) {
+  return ee[0] === Me[0] && ee[1] === Me[1];
+}
+function s(Ne, Pe, Fe, Ie = 1) {
+  let Le = Fe, Re = Math.max(Pe, 0.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, Ne2, Pe2) {
+    let Fe2 = [];
+    for (let Ne3 of ee) {
+      let ee2 = [...Ne3];
+      e(ee2[0], ee2[ee2.length - 1]) || ee2.push([ee2[0][0], ee2[0][1]]), ee2.length > 2 && Fe2.push(ee2);
+    }
+    let Ie2 = [];
+    Ne2 = Math.max(Ne2, 0.1);
+    let Le2 = [];
+    for (let ee2 of Fe2) for (let Me = 0; Me < ee2.length - 1; Me++) {
+      let Ne3 = ee2[Me], Pe3 = ee2[Me + 1];
+      if (Ne3[1] !== Pe3[1]) {
+        let ee3 = Math.min(Ne3[1], Pe3[1]);
+        Le2.push({
+          ymin: ee3,
+          ymax: Math.max(Ne3[1], Pe3[1]),
+          x: ee3 === Ne3[1] ? Ne3[0] : Pe3[0],
+          islope: (Pe3[0] - Ne3[0]) / (Pe3[1] - Ne3[1])
+        });
+      }
+    }
+    if (Le2.sort(((ee2, Me) => ee2.ymin < Me.ymin ? -1 : ee2.ymin > Me.ymin ? 1 : ee2.x < Me.x ? -1 : ee2.x > Me.x ? 1 : ee2.ymax === Me.ymax ? 0 : (ee2.ymax - Me.ymax) / Math.abs(ee2.ymax - Me.ymax))), !Le2.length) return Ie2;
+    let Re2 = [], ze2 = Le2[0].ymin, Be2 = 0;
+    for (; Re2.length || Le2.length; ) {
+      if (Le2.length) {
+        let ee2 = -1;
+        for (let Me = 0; Me < Le2.length && !(Le2[Me].ymin > ze2); Me++) ee2 = Me;
+        Le2.splice(0, ee2 + 1).forEach(((ee3) => {
+          Re2.push({
+            s: ze2,
+            edge: ee3
+          });
+        }));
+      }
+      if (Re2 = Re2.filter(((ee2) => !(ee2.edge.ymax <= ze2))), Re2.sort(((ee2, Me) => ee2.edge.x === Me.edge.x ? 0 : (ee2.edge.x - Me.edge.x) / Math.abs(ee2.edge.x - Me.edge.x))), (Pe2 !== 1 || Be2 % Ne2 == 0) && Re2.length > 1) for (let ee2 = 0; ee2 < Re2.length; ee2 += 2) {
+        let Me = ee2 + 1;
+        if (Me >= Re2.length) break;
+        let Ne3 = Re2[ee2].edge, Pe3 = Re2[Me].edge;
+        Ie2.push([[Math.round(Ne3.x), ze2], [Math.round(Pe3.x), ze2]]);
+      }
+      ze2 += Pe2, Re2.forEach(((ee2) => {
+        ee2.edge.x = ee2.edge.x + Pe2 * ee2.edge.islope;
+      })), Be2++;
+    }
+    return Ie2;
+  })(ze, Re, Ie);
+  if (Le) {
+    for (let Me of ze) t(Me, Be, -Le);
+    (function(Me, Ne2, Pe2) {
+      let Fe2 = [];
+      Me.forEach(((ee) => Fe2.push(...ee))), t(Fe2, Ne2, Pe2);
+    })(Ve, Be, -Le);
+  }
+  return Ve;
+}
+function n(ee, Me) {
+  var _a;
+  let Pe = Me.hachureAngle + 90, Fe = Me.hachureGap;
+  Fe < 0 && (Fe = 4 * Me.strokeWidth), Fe = Math.round(Math.max(Fe, 0.1));
+  let Ie = 1;
+  return Me.roughness >= 1 && (((_a = Me.randomizer) == null ? void 0 : _a.next()) || Math.random()) > 0.7 && (Ie = Fe), s(ee, Fe, Pe, Ie || 1);
+}
+var o = class {
+  constructor(ee) {
+    this.helper = ee;
+  }
+  fillPolygons(ee, Me) {
+    return this._fillPolygons(ee, Me);
+  }
+  _fillPolygons(ee, Me) {
+    let Ne = n(ee, Me);
+    return {
+      type: "fillSketch",
+      ops: this.renderLines(Ne, Me)
+    };
+  }
+  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(ee) {
+  let Me = ee[0], Ne = ee[1];
+  return Math.sqrt((Me[0] - Ne[0]) ** 2 + (Me[1] - Ne[1]) ** 2);
+}
+var h = class extends o {
+  fillPolygons(ee, Me) {
+    let Ne = Me.hachureGap;
+    Ne < 0 && (Ne = 4 * Me.strokeWidth), Ne = Math.max(Ne, 0.1);
+    let Fe = n(ee, Object.assign({}, Me, { hachureGap: Ne })), Le = Math.PI / 180 * Me.hachureAngle, Re = [], ze = 0.5 * Ne * Math.cos(Le), Be = 0.5 * Ne * Math.sin(Le);
+    for (let [ee2, Me2] of Fe) a([ee2, Me2]) && Re.push([[ee2[0] - ze, ee2[1] + Be], [...Me2]], [[ee2[0] + ze, ee2[1] - Be], [...Me2]]);
+    return {
+      type: "fillSketch",
+      ops: this.renderLines(Re, Me)
+    };
+  }
+}, 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, 0.1);
+    let Fe = Me.fillWeight;
+    Fe < 0 && (Fe = Me.strokeWidth / 2);
+    let Le = Pe / 4;
+    for (let Re of ee) {
+      let ee2 = a(Re), ze = ee2 / Pe, Be = Math.ceil(ze) - 1, Ve = ee2 - Be * Pe, He = (Re[0][0] + Re[1][0]) / 2 - Pe / 4, Ue = Math.min(Re[0][1], Re[1][1]);
+      for (let ee3 = 0; ee3 < Be; ee3++) {
+        let Ie = Ue + Ve + ee3 * Pe, Re2 = He - Le + 2 * Math.random() * Le, ze2 = Ie - Le + 2 * Math.random() * Le, Be2 = this.helper.ellipse(Re2, ze2, Fe, Fe, Me);
+        Ne.push(...Be2.ops);
+      }
+    }
+    return {
+      type: "fillSketch",
+      ops: Ne
+    };
+  }
+}, c = class {
+  constructor(ee) {
+    this.helper = ee;
+  }
+  fillPolygons(ee, Me) {
+    let Ne = n(ee, Me);
+    return {
+      type: "fillSketch",
+      ops: this.dashedLine(Ne, Me)
+    };
+  }
+  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(((ee2) => {
+      let Le = a(ee2), Re = Math.floor(Le / (Ne + Pe)), ze = (Le + Pe - Re * (Ne + Pe)) / 2, Be = ee2[0], Ve = ee2[1];
+      Be[0] > Ve[0] && (Be = ee2[1], Ve = ee2[0]);
+      let He = Math.atan((Ve[1] - Be[1]) / (Ve[0] - Be[0]));
+      for (let ee3 = 0; ee3 < Re; ee3++) {
+        let Ie = ee3 * (Ne + Pe), Le2 = Ie + Ne, Re2 = [Be[0] + Ie * Math.cos(He) + ze * Math.cos(He), Be[1] + Ie * Math.sin(He) + ze * Math.sin(He)], Ve2 = [Be[0] + Le2 * Math.cos(He) + ze * Math.cos(He), Be[1] + Le2 * Math.sin(He) + ze * Math.sin(He)];
+        Fe.push(...this.helper.doubleLineOps(Re2[0], Re2[1], Ve2[0], Ve2[1], Me));
+      }
+    })), Fe;
+  }
+}, l = class {
+  constructor(ee) {
+    this.helper = ee;
+  }
+  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(Ie, Fe, Me)
+    };
+  }
+  zigzagLines(ee, Me, Ne) {
+    let Pe = [];
+    return ee.forEach(((ee2) => {
+      let Fe = a(ee2), Le = Math.round(Fe / (2 * Me)), Re = ee2[0], ze = ee2[1];
+      Re[0] > ze[0] && (Re = ee2[1], ze = ee2[0]);
+      let Be = Math.atan((ze[1] - Re[1]) / (ze[0] - Re[0]));
+      for (let ee3 = 0; ee3 < Le; ee3++) {
+        let Fe2 = 2 * ee3 * Me, Ie = 2 * (ee3 + 1) * Me, Le2 = Math.sqrt(2 * Me ** 2), ze2 = [Re[0] + Fe2 * Math.cos(Be), Re[1] + Fe2 * Math.sin(Be)], Ve = [Re[0] + Ie * Math.cos(Be), Re[1] + Ie * Math.sin(Be)], He = [ze2[0] + Le2 * Math.cos(Be + Math.PI / 4), ze2[1] + Le2 * Math.sin(Be + Math.PI / 4)];
+        Pe.push(...this.helper.doubleLineOps(ze2[0], ze2[1], He[0], He[1], Ne), ...this.helper.doubleLineOps(He[0], He[1], Ve[0], Ve[1], Ne));
+      }
+    })), Pe;
+  }
+}, 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();
+  }
+}, f = 0, d = 1, g = 2, M = {
+  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 k(ee, Me) {
+  return ee.type === Me;
+}
+function b(ee) {
+  let Me = [], Ne = (function(ee2) {
+    let Me2 = [];
+    for (; ee2 !== ""; ) if (ee2.match(/^([ \t\r\n,]+)/)) ee2 = ee2.substr(RegExp.$1.length);
+    else if (ee2.match(/^([aAcChHlLmMqQsStTvVzZ])/)) Me2[Me2.length] = {
+      type: f,
+      text: RegExp.$1
+    }, ee2 = ee2.substr(RegExp.$1.length);
+    else {
+      if (!ee2.match(/^(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)/)) return [];
+      Me2[Me2.length] = {
+        type: d,
+        text: `${parseFloat(RegExp.$1)}`
+      }, ee2 = ee2.substr(RegExp.$1.length);
+    }
+    return Me2[Me2.length] = {
+      type: g,
+      text: ""
+    }, Me2;
+  })(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 ee2 = Fe; ee2 < Fe + Le; ee2++) {
+      let Me2 = Ne[ee2];
+      if (!k(Me2, d)) throw Error("Param not a number: " + Pe + "," + Me2.text);
+      Re[Re.length] = +Me2.text;
+    }
+    if (typeof M[Pe] != "number") throw Error("Bad segment: " + Pe);
+    {
+      let ee2 = {
+        key: Pe,
+        data: Re
+      };
+      Me.push(ee2), Fe += Le, Ie = Ne[Fe], Pe === "M" && (Pe = "L"), Pe === "m" && (Pe = "l");
+    }
+  }
+  return Me;
+}
+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":
+      Ie.push({
+        key: "M",
+        data: [...Re]
+      }), [Me, Ne] = Re, [Pe, Fe] = Re;
+      break;
+    case "m":
+      Me += Re[0], Ne += Re[1], Ie.push({
+        key: "M",
+        data: [Me, Ne]
+      }), Pe = Me, Fe = Ne;
+      break;
+    case "L":
+      Ie.push({
+        key: "L",
+        data: [...Re]
+      }), [Me, Ne] = Re;
+      break;
+    case "l":
+      Me += Re[0], Ne += Re[1], Ie.push({
+        key: "L",
+        data: [Me, Ne]
+      });
+      break;
+    case "C":
+      Ie.push({
+        key: "C",
+        data: [...Re]
+      }), Me = Re[4], Ne = Re[5];
+      break;
+    case "c": {
+      let ee2 = Re.map(((ee3, Pe2) => Pe2 % 2 ? ee3 + Ne : ee3 + Me));
+      Ie.push({
+        key: "C",
+        data: ee2
+      }), Me = ee2[4], Ne = ee2[5];
+      break;
+    }
+    case "Q":
+      Ie.push({
+        key: "Q",
+        data: [...Re]
+      }), Me = Re[2], Ne = Re[3];
+      break;
+    case "q": {
+      let ee2 = Re.map(((ee3, Pe2) => Pe2 % 2 ? ee3 + Ne : ee3 + Me));
+      Ie.push({
+        key: "Q",
+        data: ee2
+      }), Me = ee2[2], Ne = ee2[3];
+      break;
+    }
+    case "A":
+      Ie.push({
+        key: "A",
+        data: [...Re]
+      }), Me = Re[5], Ne = Re[6];
+      break;
+    case "a":
+      Me += Re[5], Ne += Re[6], Ie.push({
+        key: "A",
+        data: [
+          Re[0],
+          Re[1],
+          Re[2],
+          Re[3],
+          Re[4],
+          Me,
+          Ne
+        ]
+      });
+      break;
+    case "H":
+      Ie.push({
+        key: "H",
+        data: [...Re]
+      }), Me = Re[0];
+      break;
+    case "h":
+      Me += Re[0], Ie.push({
+        key: "H",
+        data: [Me]
+      });
+      break;
+    case "V":
+      Ie.push({
+        key: "V",
+        data: [...Re]
+      }), Ne = Re[0];
+      break;
+    case "v":
+      Ne += Re[0], Ie.push({
+        key: "V",
+        data: [Ne]
+      });
+      break;
+    case "S":
+      Ie.push({
+        key: "S",
+        data: [...Re]
+      }), Me = Re[2], Ne = Re[3];
+      break;
+    case "s": {
+      let ee2 = Re.map(((ee3, Pe2) => Pe2 % 2 ? ee3 + Ne : ee3 + Me));
+      Ie.push({
+        key: "S",
+        data: ee2
+      }), Me = ee2[2], Ne = ee2[3];
+      break;
+    }
+    case "T":
+      Ie.push({
+        key: "T",
+        data: [...Re]
+      }), Me = Re[0], Ne = Re[1];
+      break;
+    case "t":
+      Me += Re[0], Ne += Re[1], Ie.push({
+        key: "T",
+        data: [Me, Ne]
+      });
+      break;
+    case "Z":
+    case "z":
+      Ie.push({
+        key: "Z",
+        data: []
+      }), Me = Pe, Ne = Fe;
+  }
+  return Ie;
+}
+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":
+        Me.push({
+          key: "M",
+          data: [...Ve]
+        }), [Pe, Fe] = Ve, [Ie, Le] = Ve;
+        break;
+      case "C":
+        Me.push({
+          key: "C",
+          data: [...Ve]
+        }), Pe = Ve[4], Fe = Ve[5], Re = Ve[2], ze = Ve[3];
+        break;
+      case "L":
+        Me.push({
+          key: "L",
+          data: [...Ve]
+        }), [Pe, Fe] = Ve;
+        break;
+      case "H":
+        Pe = Ve[0], Me.push({
+          key: "L",
+          data: [Pe, Fe]
+        });
+        break;
+      case "V":
+        Fe = Ve[0], Me.push({
+          key: "L",
+          data: [Pe, Fe]
+        });
+        break;
+      case "S": {
+        let ee2 = 0, Ie2 = 0;
+        Ne === "C" || Ne === "S" ? (ee2 = Pe + (Pe - Re), Ie2 = Fe + (Fe - ze)) : (ee2 = Pe, Ie2 = Fe), Me.push({
+          key: "C",
+          data: [
+            ee2,
+            Ie2,
+            ...Ve
+          ]
+        }), Re = Ve[0], ze = Ve[1], Pe = Ve[2], Fe = Ve[3];
+        break;
+      }
+      case "T": {
+        let [ee2, Ie2] = Ve, Le2 = 0, Be2 = 0;
+        Ne === "Q" || Ne === "T" ? (Le2 = Pe + (Pe - Re), Be2 = Fe + (Fe - ze)) : (Le2 = Pe, Be2 = Fe);
+        let He = Pe + 2 * (Le2 - Pe) / 3, Ue = Fe + 2 * (Be2 - Fe) / 3, We = ee2 + 2 * (Le2 - ee2) / 3, Ge = Ie2 + 2 * (Be2 - Ie2) / 3;
+        Me.push({
+          key: "C",
+          data: [
+            He,
+            Ue,
+            We,
+            Ge,
+            ee2,
+            Ie2
+          ]
+        }), Re = Le2, ze = Be2, Pe = ee2, Fe = Ie2;
+        break;
+      }
+      case "Q": {
+        let [ee2, Ne2, Ie2, Le2] = Ve, Be2 = Pe + 2 * (ee2 - Pe) / 3, He = Fe + 2 * (Ne2 - Fe) / 3, Ue = Ie2 + 2 * (ee2 - Ie2) / 3, We = Le2 + 2 * (Ne2 - Le2) / 3;
+        Me.push({
+          key: "C",
+          data: [
+            Be2,
+            He,
+            Ue,
+            We,
+            Ie2,
+            Le2
+          ]
+        }), Re = ee2, ze = Ne2, Pe = Ie2, Fe = Le2;
+        break;
+      }
+      case "A": {
+        let ee2 = Math.abs(Ve[0]), Ne2 = Math.abs(Ve[1]), Ie2 = Ve[2], Le2 = Ve[3], Re2 = Ve[4], ze2 = Ve[5], Be2 = Ve[6];
+        ee2 === 0 || Ne2 === 0 ? (Me.push({
+          key: "C",
+          data: [
+            Pe,
+            Fe,
+            ze2,
+            Be2,
+            ze2,
+            Be2
+          ]
+        }), Pe = ze2, Fe = Be2) : (Pe !== ze2 || Fe !== Be2) && (x(Pe, Fe, ze2, Be2, ee2, Ne2, Ie2, Le2, Re2).forEach((function(ee3) {
+          Me.push({
+            key: "C",
+            data: ee3
+          });
+        })), Pe = ze2, Fe = Be2);
+        break;
+      }
+      case "Z":
+        Me.push({
+          key: "Z",
+          data: []
+        }), Pe = Ie, Fe = Le;
+    }
+    Ne = Be;
+  }
+  return Me;
+}
+function w(ee, Me, Ne) {
+  return [ee * Math.cos(Ne) - Me * Math.sin(Ne), ee * Math.sin(Ne) + Me * Math.cos(Ne)];
+}
+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 {
+    [ee, Me] = w(ee, Me, -Ve), [Ne, Pe] = w(Ne, Pe, -Ve);
+    let Le2 = (ee - Ne) / 2, Be2 = (Me - Pe) / 2, He2 = Le2 * Le2 / (Fe * Fe) + Be2 * Be2 / (Ie * Ie);
+    He2 > 1 && (He2 = Math.sqrt(He2), Fe *= He2, Ie *= He2);
+    let Ue2 = Fe * Fe, Je2 = Ie * Ie, Ye2 = Ue2 * Je2 - Ue2 * Be2 * Be2 - Je2 * Le2 * Le2, Xe2 = Ue2 * Be2 * Be2 + Je2 * Le2 * Le2, Ze2 = (Re === ze ? -1 : 1) * Math.sqrt(Math.abs(Ye2 / Xe2));
+    Ke = Ze2 * Fe * Be2 / Ie + (ee + Ne) / 2, qe = Ze2 * -Ie * Le2 / 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 ee2 = Ge, Me2 = Ne, Re2 = 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), Me2, Re2, Fe, Ie, Le, 0, ze, [
+      Ge,
+      ee2,
+      Ke,
+      qe
+    ]);
+  }
+  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);
+  {
+    Ue = [
+      lt,
+      ut,
+      dt
+    ].concat(Ue);
+    let ee2 = [];
+    for (let Me2 = 0; Me2 < Ue.length; Me2 += 3) {
+      let Ne2 = w(Ue[Me2][0], Ue[Me2][1], Ve), Pe2 = w(Ue[Me2 + 1][0], Ue[Me2 + 1][1], Ve), Fe2 = w(Ue[Me2 + 2][0], Ue[Me2 + 2][1], Ve);
+      ee2.push([
+        Ne2[0],
+        Ne2[1],
+        Pe2[0],
+        Pe2[1],
+        Fe2[0],
+        Fe2[1]
+      ]);
+    }
+    return ee2;
+  }
+}
+var P = {
+  randOffset: function(ee, Me) {
+    return G(ee, Me);
+  },
+  randOffsetWithRange: function(ee, Me, Ne) {
+    return E(ee, Me, Ne);
+  },
+  ellipse: function(ee, Me, Ne, Pe, Fe) {
+    return D(ee, Me, Fe, T(Ne, Pe, Fe)).opset;
+  },
+  doubleLineOps: function(ee, Me, Ne, Pe, Fe) {
+    return $(ee, Me, Ne, Pe, Fe, true);
+  }
+};
+function v(ee, Me, Ne, Pe, Fe) {
+  return {
+    type: "path",
+    ops: $(ee, Me, Ne, Pe, Fe)
+  };
+}
+function S(ee, Me, Ne) {
+  let Pe = (ee || []).length;
+  if (Pe > 2) {
+    let Fe = [];
+    for (let Me2 = 0; Me2 < Pe - 1; Me2++) Fe.push(...$(ee[Me2][0], ee[Me2][1], ee[Me2 + 1][0], ee[Me2 + 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: Fe
+    };
+  }
+  return Pe === 2 ? v(ee[0][0], ee[0][1], ee[1][0], ee[1][1], Ne) : {
+    type: "path",
+    ops: []
+  };
+}
+function O(ee, Me, Ne, Pe, Fe) {
+  return (function(ee2, Me2) {
+    return S(ee2, true, Me2);
+  })([
+    [ee, Me],
+    [ee + Ne, Me],
+    [ee + Ne, Me + Pe],
+    [ee, Me + Pe]
+  ], Fe);
+}
+function L(ee, Me) {
+  if (ee.length) {
+    let Ne = typeof ee[0][0] == "number" ? [ee] : ee, Pe = j(Ne[0], 1 * (1 + 0.2 * Me.roughness), Me), Fe = Me.disableMultiStroke ? [] : j(Ne[0], 1.5 * (1 + 0.22 * Me.roughness), z(Me));
+    for (let ee2 = 1; ee2 < Ne.length; ee2++) {
+      let Ie = Ne[ee2];
+      if (Ie.length) {
+        let ee3 = j(Ie, 1 * (1 + 0.2 * Me.roughness), Me), Ne2 = Me.disableMultiStroke ? [] : j(Ie, 1.5 * (1 + 0.22 * Me.roughness), z(Me));
+        for (let Me2 of ee3) Me2.op !== "move" && Pe.push(Me2);
+        for (let ee4 of Ne2) ee4.op !== "move" && Fe.push(ee4);
+      }
+    }
+    return {
+      type: "path",
+      ops: Pe.concat(Fe)
+    };
+  }
+  return {
+    type: "path",
+    ops: []
+  };
+}
+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 D(ee, Me, Ne, Pe) {
+  let [Fe, Ie] = F(Pe.increment, ee, Me, Pe.rx, Pe.ry, 1, Pe.increment * E(0.1, E(0.4, 1, Ne), Ne), Ne), Le = q(Fe, null, Ne);
+  if (!Ne.disableMultiStroke && Ne.roughness !== 0) {
+    let [Fe2] = F(Pe.increment, ee, Me, Pe.rx, Pe.ry, 1.5, 0, Ne), Ie2 = q(Fe2, null, Ne);
+    Le = Le.concat(Ie2);
+  }
+  return {
+    estimatedPoints: Ie,
+    opset: {
+      type: "path",
+      ops: Le
+    }
+  };
+}
+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(0.01 * He, ze), Ue += G(0.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 ee2 = V(qe, Be, Ve, He, Ue, We, Ge, 1.5, ze);
+    Je.push(...ee2);
+  }
+  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: [Be, Ve]
+  }, {
+    op: "lineTo",
+    data: [Be + He * Math.cos(We), Ve + Ue * Math.sin(We)]
+  })), {
+    type: "path",
+    ops: Je
+  };
+}
+function _(ee, Me) {
+  let Ne = m(y(b(ee))), Pe = [], Fe = [0, 0], Ie = [0, 0];
+  for (let { key: ee2, data: Le } of Ne) switch (ee2) {
+    case "M":
+      Ie = [Le[0], Le[1]], Fe = [Le[0], Le[1]];
+      break;
+    case "L":
+      Pe.push(...$(Ie[0], Ie[1], Le[0], Le[1], Me)), Ie = [Le[0], Le[1]];
+      break;
+    case "C": {
+      let [ee3, Ne2, Fe2, Re, ze, Be] = Le;
+      Pe.push(...Z(ee3, Ne2, Fe2, Re, ze, Be, Ie, Me)), Ie = [ze, Be];
+      break;
+    }
+    case "Z":
+      Pe.push(...$(Ie[0], Ie[1], Fe[0], Fe[1], Me)), Ie = [Fe[0], Fe[1]];
+  }
+  return {
+    type: "path",
+    ops: Pe
+  };
+}
+function I(ee, Me) {
+  let Ne = [];
+  for (let Pe of ee) if (Pe.length) {
+    let ee2 = Me.maxRandomnessOffset || 0, Fe = Pe.length;
+    if (Fe > 2) {
+      Ne.push({
+        op: "move",
+        data: [Pe[0][0] + G(ee2, Me), Pe[0][1] + G(ee2, Me)]
+      });
+      for (let Ie = 1; Ie < Fe; Ie++) Ne.push({
+        op: "lineTo",
+        data: [Pe[Ie][0] + G(ee2, Me), Pe[Ie][1] + G(ee2, Me)]
+      });
+    }
+  }
+  return {
+    type: "fillPath",
+    ops: Ne
+  };
+}
+function C(ee, Me) {
+  return (function(ee2, Me2) {
+    let Ne = ee2.fillStyle || "hachure";
+    if (!u[Ne]) switch (Ne) {
+      case "zigzag":
+        u[Ne] || (u[Ne] = new h(Me2));
+        break;
+      case "cross-hatch":
+        u[Ne] || (u[Ne] = new r(Me2));
+        break;
+      case "dots":
+        u[Ne] || (u[Ne] = new i(Me2));
+        break;
+      case "dashed":
+        u[Ne] || (u[Ne] = new c(Me2));
+        break;
+      case "zigzag-line":
+        u[Ne] || (u[Ne] = new l(Me2));
+        break;
+      default:
+        Ne = "hachure", u[Ne] || (u[Ne] = new o(Me2));
+    }
+    return u[Ne];
+  })(Me, P).fillPolygons(ee, Me);
+}
+function z(ee) {
+  let Me = Object.assign({}, ee);
+  return Me.randomizer = void 0, ee.seed && (Me.seed = ee.seed + 1), Me;
+}
+function W(ee) {
+  return ee.randomizer || (ee.randomizer = new p(ee.seed || 0)), ee.randomizer.next();
+}
+function E(ee, Me, Ne, Pe = 1) {
+  return Ne.roughness * Pe * (W(Ne) * (Me - ee) + ee);
+}
+function G(ee, Me, Ne = 1) {
+  return E(-ee, ee, Me, Ne);
+}
+function $(ee, Me, Ne, Pe, Fe, Ie = false) {
+  let Le = Ie ? Fe.disableMultiStrokeFill : Fe.disableMultiStroke, Re = R(ee, Me, Ne, Pe, Fe, true, false);
+  if (Le) return Re;
+  let ze = R(ee, Me, Ne, Pe, Fe, true, true);
+  return Re.concat(ze);
+}
+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 ? 0.4 : -16668e-7 * ze + 1.233334;
+  let Ve = Fe.maxRandomnessOffset || 0;
+  Ve * Ve * 100 > Re && (Ve = ze / 10);
+  let He = Ve / 2, Ue = 0.2 + 0.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: [ee + (Ye ? 0 : qe()), Me + (Ye ? 0 : qe())]
+  }) : Ke.push({
+    op: "move",
+    data: [ee + (Ye ? 0 : G(Ve, Fe, Be)), Me + (Ye ? 0 : G(Ve, Fe, Be))]
+  })), Le ? Ke.push({
+    op: "bcurveTo",
+    data: [
+      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())
+    ]
+  }) : Ke.push({
+    op: "bcurveTo",
+    data: [
+      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())
+    ]
+  }), Ke;
+}
+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 q(ee, Me, Ne) {
+  let Pe = ee.length, Fe = [];
+  if (Pe > 3) {
+    let Ie = [], Le = 1 - Ne.curveTightness;
+    Fe.push({
+      op: "move",
+      data: [ee[1][0], ee[1][1]]
+    });
+    for (let Me2 = 1; Me2 + 2 < Pe; Me2++) {
+      let Ne2 = ee[Me2];
+      Ie[0] = [Ne2[0], Ne2[1]], Ie[1] = [Ne2[0] + (Le * ee[Me2 + 1][0] - Le * ee[Me2 - 1][0]) / 6, Ne2[1] + (Le * ee[Me2 + 1][1] - Le * ee[Me2 - 1][1]) / 6], Ie[2] = [ee[Me2 + 1][0] + (Le * ee[Me2][0] - Le * ee[Me2 + 2][0]) / 6, ee[Me2 + 1][1] + (Le * ee[Me2][1] - Le * ee[Me2 + 2][1]) / 6], Ie[3] = [ee[Me2 + 1][0], ee[Me2 + 1][1]], Fe.push({
+        op: "bcurveTo",
+        data: [
+          Ie[1][0],
+          Ie[1][1],
+          Ie[2][0],
+          Ie[2][1],
+          Ie[3][0],
+          Ie[3][1]
+        ]
+      });
+    }
+    if (Me && Me.length === 2) {
+      let ee2 = Ne.maxRandomnessOffset;
+      Fe.push({
+        op: "lineTo",
+        data: [Me[0] + G(ee2, Ne), Me[1] + G(ee2, Ne)]
+      });
+    }
+  } else Pe === 3 ? (Fe.push({
+    op: "move",
+    data: [ee[1][0], ee[1][1]]
+  }), Fe.push({
+    op: "bcurveTo",
+    data: [
+      ee[1][0],
+      ee[1][1],
+      ee[2][0],
+      ee[2][1],
+      ee[2][0],
+      ee[2][1]
+    ]
+  })) : Pe === 2 && Fe.push(...R(ee[0][0], ee[0][1], ee[1][0], ee[1][1], Ne, true, true));
+  return Fe;
+}
+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 Ie2 = 0; Ie2 <= 2 * Math.PI; Ie2 += ee) {
+      let ee2 = [Me + Pe * Math.cos(Ie2), Ne + Fe * Math.sin(Ie2)];
+      ze.push(ee2), Be.push(ee2);
+    }
+    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 Ve = G(0.5, Re) - Math.PI / 2;
+    Be.push([G(Ie, Re) + Me + 0.9 * Pe * Math.cos(Ve - ee), G(Ie, Re) + Ne + 0.9 * Fe * Math.sin(Ve - ee)]);
+    let He = 2 * Math.PI + Ve - 0.01;
+    for (let Le2 = Ve; Le2 < He; Le2 += ee) {
+      let ee2 = [G(Ie, Re) + Me + Pe * Math.cos(Le2), G(Ie, Re) + Ne + Fe * Math.sin(Le2)];
+      ze.push(ee2), Be.push(ee2);
+    }
+    Be.push([G(Ie, Re) + Me + Pe * Math.cos(Ve + 2 * Math.PI + 0.5 * Le), G(Ie, Re) + Ne + Fe * Math.sin(Ve + 2 * Math.PI + 0.5 * Le)]), Be.push([G(Ie, Re) + Me + 0.98 * Pe * Math.cos(Ve + Le), G(Ie, Re) + Ne + 0.98 * Fe * Math.sin(Ve + Le)]), Be.push([G(Ie, Re) + Me + 0.9 * Pe * Math.cos(Ve + 0.5 * Le), G(Ie, Re) + Ne + 0.9 * Fe * Math.sin(Ve + 0.5 * Le)]);
+  }
+  return [Be, ze];
+}
+function V(ee, Me, Ne, Pe, Fe, Ie, Le, Re, ze) {
+  let Be = Ie + G(0.1, ze), Ve = [];
+  Ve.push([G(Re, ze) + Me + 0.9 * Pe * Math.cos(Be - ee), G(Re, ze) + Ne + 0.9 * Fe * Math.sin(Be - ee)]);
+  for (let Ie2 = Be; Ie2 <= Le; Ie2 += ee) Ve.push([G(Re, ze) + Me + Pe * Math.cos(Ie2), G(Re, ze) + Ne + Fe * Math.sin(Ie2)]);
+  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 Z(ee, Me, Ne, Pe, Fe, Ie, Le, Re) {
+  let ze = [], Be = [Re.maxRandomnessOffset || 1, (Re.maxRandomnessOffset || 1) + 0.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: [Le[0], Le[1]]
+  }) : ze.push({
+    op: "move",
+    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: [
+      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 ze;
+}
+function Q(ee) {
+  return [...ee];
+}
+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 Ne2 = [];
+    Ne2.push(ee[0], ee[0]);
+    for (let Me2 = 1; Me2 < ee.length; Me2++) Ne2.push(ee[Me2]), Me2 === ee.length - 1 && Ne2.push(ee[Me2]);
+    let Fe = [], Ie = 1 - Me;
+    Pe.push(Q(Ne2[0]));
+    for (let ee2 = 1; ee2 + 2 < Ne2.length; ee2++) {
+      let Me2 = Ne2[ee2];
+      Fe[0] = [Me2[0], Me2[1]], Fe[1] = [Me2[0] + (Ie * Ne2[ee2 + 1][0] - Ie * Ne2[ee2 - 1][0]) / 6, Me2[1] + (Ie * Ne2[ee2 + 1][1] - Ie * Ne2[ee2 - 1][1]) / 6], Fe[2] = [Ne2[ee2 + 1][0] + (Ie * Ne2[ee2][0] - Ie * Ne2[ee2 + 2][0]) / 6, Ne2[ee2 + 1][1] + (Ie * Ne2[ee2][1] - Ie * Ne2[ee2 + 2][1]) / 6], Fe[3] = [Ne2[ee2 + 1][0], Ne2[ee2 + 1][1]], Pe.push(Fe[1], Fe[2], Fe[3]);
+    }
+  }
+  return Pe;
+}
+function N(ee, Me) {
+  return (ee[0] - Me[0]) ** 2 + (ee[1] - Me[1]) ** 2;
+}
+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 J(ee, Me, Ne) {
+  return [ee[0] + (Me[0] - ee[0]) * Ne, ee[1] + (Me[1] - ee[1]) * Ne];
+}
+function K(ee, Me, Ne, Pe) {
+  let Fe = Pe || [];
+  if ((function(ee2, Me2) {
+    let Ne2 = ee2[Me2 + 0], Pe2 = ee2[Me2 + 1], Fe2 = ee2[Me2 + 2], Ie2 = ee2[Me2 + 3], Le2 = 3 * Pe2[0] - 2 * Ne2[0] - Ie2[0];
+    Le2 *= Le2;
+    let Re = 3 * Pe2[1] - 2 * Ne2[1] - Ie2[1];
+    Re *= Re;
+    let ze = 3 * Fe2[0] - 2 * Ie2[0] - Ne2[0];
+    ze *= ze;
+    let Be = 3 * Fe2[1] - 2 * Ie2[1] - Ne2[1];
+    return Be *= Be, Le2 < ze && (Le2 = ze), Re < Be && (Re = Be), Le2 + Re;
+  })(ee, Me) < Ne) {
+    let Ne2 = ee[Me + 0];
+    Fe.length ? (Ie = Fe[Fe.length - 1], Le = Ne2, Math.sqrt(N(Ie, Le))) > 1 && Fe.push(Ne2) : Fe.push(Ne2), Fe.push(ee[Me + 3]);
+  } else {
+    let Pe2 = 0.5, Ie2 = ee[Me + 0], Le2 = ee[Me + 1], Re = ee[Me + 2], ze = ee[Me + 3], Be = J(Ie2, Le2, Pe2), Ve = J(Le2, Re, Pe2), He = J(Re, ze, Pe2), Ue = J(Be, Ve, Pe2), We = J(Ve, He, Pe2), Ge = J(Ue, We, Pe2);
+    K([
+      Ie2,
+      Be,
+      Ue,
+      Ge
+    ], 0, Ne, Fe), K([
+      Ge,
+      We,
+      He,
+      ze
+    ], 0, Ne, Fe);
+  }
+  var Ie, Le;
+  return Fe;
+}
+function U(ee, Me) {
+  return X(ee, 0, ee.length, Me);
+}
+function X(ee, Me, Ne, Pe, Fe) {
+  let Ie = Fe || [], Le = ee[Me], Re = ee[Ne - 1], ze = 0, Be = 1;
+  for (let Pe2 = Me + 1; Pe2 < Ne - 1; ++Pe2) {
+    let Me2 = B(ee[Pe2], Le, Re);
+    Me2 > ze && (ze = Me2, Be = Pe2);
+  }
+  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 Y(ee, Me = 0.15, Ne) {
+  let Pe = [], Fe = (ee.length - 1) / 3;
+  for (let Ne2 = 0; Ne2 < Fe; Ne2++) K(ee, 3 * Ne2, Me, Pe);
+  return Ne && Ne > 0 ? X(Pe, 0, Pe.length, Ne) : Pe;
+}
+var tt = "none", et = class {
+  constructor(ee) {
+    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: false,
+      disableMultiStrokeFill: false,
+      preserveVertices: false,
+      fillShapeRoughnessGain: 0.8
+    }, this.config = ee || {}, this.config.options && (this.defaultOptions = this._o(this.config.options));
+  }
+  static newSeed() {
+    return Math.floor(Math.random() * 2 ** 31);
+  }
+  _o(ee) {
+    return ee ? Object.assign({}, this.defaultOptions, ee) : this.defaultOptions;
+  }
+  _d(ee, Me, Ne) {
+    return {
+      shape: ee,
+      sets: Me || [],
+      options: Ne || this.defaultOptions
+    };
+  }
+  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 Fe2 = [
+        [ee, Me],
+        [ee + Ne, Me],
+        [ee + Ne, Me + Pe],
+        [ee, Me + Pe]
+      ];
+      Ie.fillStyle === "solid" ? Le.push(I([Fe2], Ie)) : Le.push(C([Fe2], Ie));
+    }
+    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 Ne2 = D(ee, Me, Ie, Re).opset;
+      Ne2.type = "fillPath", Le.push(Ne2);
+    } 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, false, Ne)], Ne);
+  }
+  arc(ee, Me, Ne, Pe, Fe, Ie, Le = false, Re) {
+    let ze = this._o(Re), Be = [], Ve = A(ee, Me, Ne, Pe, Fe, Ie, Le, true, ze);
+    if (Le && ze.fill) if (ze.fillStyle === "solid") {
+      let Le2 = Object.assign({}, ze);
+      Le2.disableMultiStroke = true;
+      let Re2 = A(ee, Me, Ne, Pe, Fe, Ie, true, false, Le2);
+      Re2.type = "fillPath", Be.push(Re2);
+    } else Be.push((function(ee2, Me2, Ne2, Pe2, Fe2, Ie2, Le2) {
+      let Re2 = ee2, ze2 = Me2, Be2 = Math.abs(Ne2 / 2), Ve2 = Math.abs(Pe2 / 2);
+      Be2 += G(0.01 * Be2, Le2), Ve2 += G(0.01 * Ve2, Le2);
+      let He = Fe2, Ue = Ie2;
+      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) / Le2.curveStepCount, Ge = [];
+      for (let ee3 = He; ee3 <= Ue; ee3 += We) Ge.push([Re2 + Be2 * Math.cos(ee3), ze2 + Ve2 * Math.sin(ee3)]);
+      return Ge.push([Re2 + Be2 * Math.cos(Ue), ze2 + Ve2 * Math.sin(Ue)]), Ge.push([Re2, ze2]), C([Ge], Le2);
+    })(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 Me2 = L(ee, Object.assign(Object.assign({}, Ne), {
+        disableMultiStroke: true,
+        roughness: Ne.roughness ? Ne.roughness + Ne.fillShapeRoughnessGain : 0
+      }));
+      Pe.push({
+        type: "fillPath",
+        ops: this._mergedShape(Me2.ops)
+      });
+    } else {
+      let Me2 = [], Fe2 = ee;
+      if (Fe2.length) {
+        let ee2 = typeof Fe2[0][0] == "number" ? [Fe2] : Fe2;
+        for (let Pe2 of ee2) Pe2.length < 3 ? Me2.push(...Pe2) : Pe2.length === 3 ? Me2.push(...Y(H([
+          Pe2[0],
+          Pe2[0],
+          Pe2[1],
+          Pe2[2]
+        ]), 10, (1 + Ne.roughness) / 2)) : Me2.push(...Y(H(Pe2), 10, (1 + Ne.roughness) / 2));
+      }
+      Me2.length && Pe.push(C([Me2], Ne));
+    }
+    return Ne.stroke !== tt && Pe.push(Fe), this._d("curve", Pe, Ne);
+  }
+  polygon(ee, Me) {
+    let Ne = this._o(Me), Pe = [], Fe = S(ee, true, 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(ee2, Me2, Ne2) {
+      let Pe2 = m(y(b(ee2))), Fe2 = [], Ie2 = [], Le2 = [0, 0], Re2 = [], ze2 = () => {
+        Re2.length >= 4 && Ie2.push(...Y(Re2, Me2)), Re2 = [];
+      }, Be = () => {
+        ze2(), Ie2.length && (Fe2.push(Ie2), Ie2 = []);
+      };
+      for (let { key: ee3, data: Me3 } of Pe2) switch (ee3) {
+        case "M":
+          Be(), Le2 = [Me3[0], Me3[1]], Ie2.push(Le2);
+          break;
+        case "L":
+          ze2(), Ie2.push([Me3[0], Me3[1]]);
+          break;
+        case "C":
+          if (!Re2.length) {
+            let ee4 = Ie2.length ? Ie2[Ie2.length - 1] : Le2;
+            Re2.push([ee4[0], ee4[1]]);
+          }
+          Re2.push([Me3[0], Me3[1]]), Re2.push([Me3[2], Me3[3]]), Re2.push([Me3[4], Me3[5]]);
+          break;
+        case "Z":
+          ze2(), Ie2.push([Le2[0], Le2[1]]);
+      }
+      if (Be(), !Ne2) return Fe2;
+      let Ve = [];
+      for (let ee3 of Fe2) {
+        let Me3 = U(ee3, Ne2);
+        Me3.length && Ve.push(Me3);
+      }
+      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 Me2 = _(ee, Object.assign(Object.assign({}, Ne), {
+        disableMultiStroke: true,
+        roughness: Ne.roughness ? Ne.roughness + Ne.fillShapeRoughnessGain : 0
+      }));
+      Pe.push({
+        type: "fillPath",
+        ops: this._mergedShape(Me2.ops)
+      });
+    } else Pe.push(I(Re, Ne));
+    else Pe.push(C(Re, Ne));
+    return Ie && (Le ? Re.forEach(((ee2) => {
+      Pe.push(S(ee2, false, Ne));
+    })) : Pe.push(ze)), this._d("path", Pe, Ne);
+  }
+  opsToPath(ee, Me) {
+    let Ne = "";
+    for (let Pe of ee.ops) {
+      let ee2 = typeof Me == "number" && Me >= 0 ? Pe.data.map(((ee3) => +ee3.toFixed(Me))) : Pe.data;
+      switch (Pe.op) {
+        case "move":
+          Ne += `M${ee2[0]} ${ee2[1]} `;
+          break;
+        case "bcurveTo":
+          Ne += `C${ee2[0]} ${ee2[1]}, ${ee2[2]} ${ee2[3]}, ${ee2[4]} ${ee2[5]} `;
+          break;
+        case "lineTo":
+          Ne += `L${ee2[0]} ${ee2[1]} `;
+      }
+    }
+    return Ne.trim();
+  }
+  toPaths(ee) {
+    let Me = ee.sets || [], Ne = ee.options || this.defaultOptions, Pe = [];
+    for (let ee2 of Me) {
+      let Me2 = null;
+      switch (ee2.type) {
+        case "path":
+          Me2 = {
+            d: this.opsToPath(ee2),
+            stroke: Ne.stroke,
+            strokeWidth: Ne.strokeWidth,
+            fill: tt
+          };
+          break;
+        case "fillPath":
+          Me2 = {
+            d: this.opsToPath(ee2),
+            stroke: tt,
+            strokeWidth: 0,
+            fill: Ne.fill || tt
+          };
+          break;
+        case "fillSketch":
+          Me2 = this.fillSketch(ee2, Ne);
+      }
+      Me2 && Pe.push(Me2);
+    }
+    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(ee) {
+    return ee.filter(((ee2, Me) => Me === 0 || ee2.op !== "move"));
+  }
+}, st = class {
+  constructor(ee, Me) {
+    this.canvas = ee, this.ctx = this.canvas.getContext("2d"), this.gen = new et(Me);
+  }
+  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":
+        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": {
+        Pe.save(), Pe.fillStyle = Ne.fill || "";
+        let Me2 = ee.shape === "curve" || ee.shape === "polygon" || ee.shape === "path" ? "evenodd" : "nonzero";
+        this._drawToContext(Pe, Ie, Fe, Me2), Pe.restore();
+        break;
+      }
+      case "fillSketch":
+        this.fillSketch(Pe, Ie, Ne);
+    }
+  }
+  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(ee, Me, Ne, Pe = "nonzero") {
+    ee.beginPath();
+    for (let Pe2 of Me.ops) {
+      let Me2 = typeof Ne == "number" && Ne >= 0 ? Pe2.data.map(((ee2) => +ee2.toFixed(Ne))) : Pe2.data;
+      switch (Pe2.op) {
+        case "move":
+          ee.moveTo(Me2[0], Me2[1]);
+          break;
+        case "bcurveTo":
+          ee.bezierCurveTo(Me2[0], Me2[1], Me2[2], Me2[3], Me2[4], Me2[5]);
+          break;
+        case "lineTo":
+          ee.lineTo(Me2[0], Me2[1]);
+      }
+    }
+    Me.type === "fillPath" ? ee.fill(Pe) : ee.stroke();
+  }
+  get generator() {
+    return this.gen;
+  }
+  getDefaultOptions() {
+    return this.gen.defaultOptions;
+  }
+  line(ee, Me, Ne, Pe, Fe) {
+    let Ie = this.gen.line(ee, Me, Ne, Pe, Fe);
+    return this.draw(Ie), Ie;
+  }
+  rectangle(ee, Me, Ne, Pe, Fe) {
+    let Ie = this.gen.rectangle(ee, Me, Ne, Pe, Fe);
+    return this.draw(Ie), Ie;
+  }
+  ellipse(ee, Me, Ne, Pe, Fe) {
+    let Ie = this.gen.ellipse(ee, Me, Ne, Pe, Fe);
+    return this.draw(Ie), Ie;
+  }
+  circle(ee, Me, Ne, Pe) {
+    let Fe = this.gen.circle(ee, Me, Ne, Pe);
+    return this.draw(Fe), Fe;
+  }
+  linearPath(ee, Me) {
+    let Ne = this.gen.linearPath(ee, Me);
+    return this.draw(Ne), Ne;
+  }
+  polygon(ee, Me) {
+    let Ne = this.gen.polygon(ee, Me);
+    return this.draw(Ne), Ne;
+  }
+  arc(ee, Me, Ne, Pe, Fe, Ie, Le = false, Re) {
+    let ze = this.gen.arc(ee, Me, Ne, Pe, Fe, Ie, Le, Re);
+    return this.draw(ze), ze;
+  }
+  curve(ee, Me) {
+    let Ne = this.gen.curve(ee, Me);
+    return this.draw(Ne), Ne;
+  }
+  path(ee, Me) {
+    let Ne = this.gen.path(ee, Me);
+    return this.draw(Ne), Ne;
+  }
+}, nt = "http://www.w3.org/2000/svg", ot = class {
+  constructor(ee, Me) {
+    this.svg = ee, this.gen = new et(Me);
+  }
+  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 Me2 = null;
+      switch (Le.type) {
+        case "path":
+          Me2 = Pe.createElementNS(nt, "path"), Me2.setAttribute("d", this.opsToPath(Le, Ie)), Me2.setAttribute("stroke", Ne.stroke), Me2.setAttribute("stroke-width", Ne.strokeWidth + ""), Me2.setAttribute("fill", "none"), Ne.strokeLineDash && Me2.setAttribute("stroke-dasharray", Ne.strokeLineDash.join(" ").trim()), Ne.strokeLineDashOffset && Me2.setAttribute("stroke-dashoffset", `${Ne.strokeLineDashOffset}`);
+          break;
+        case "fillPath":
+          Me2 = Pe.createElementNS(nt, "path"), Me2.setAttribute("d", this.opsToPath(Le, Ie)), Me2.setAttribute("stroke", "none"), Me2.setAttribute("stroke-width", "0"), Me2.setAttribute("fill", Ne.fill || ""), ee.shape !== "curve" && ee.shape !== "polygon" || Me2.setAttribute("fill-rule", "evenodd");
+          break;
+        case "fillSketch":
+          Me2 = this.fillSketch(Pe, Le, Ne);
+      }
+      Me2 && Fe.appendChild(Me2);
+    }
+    return Fe;
+  }
+  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;
+  }
+  getDefaultOptions() {
+    return this.gen.defaultOptions;
+  }
+  opsToPath(ee, Me) {
+    return this.gen.opsToPath(ee, Me);
+  }
+  line(ee, Me, Ne, Pe, Fe) {
+    let Ie = this.gen.line(ee, Me, Ne, Pe, Fe);
+    return this.draw(Ie);
+  }
+  rectangle(ee, Me, Ne, Pe, Fe) {
+    let Ie = this.gen.rectangle(ee, Me, Ne, Pe, Fe);
+    return this.draw(Ie);
+  }
+  ellipse(ee, Me, Ne, Pe, Fe) {
+    let Ie = this.gen.ellipse(ee, Me, Ne, Pe, Fe);
+    return this.draw(Ie);
+  }
+  circle(ee, Me, Ne, Pe) {
+    let Fe = this.gen.circle(ee, Me, Ne, Pe);
+    return this.draw(Fe);
+  }
+  linearPath(ee, Me) {
+    let Ne = this.gen.linearPath(ee, Me);
+    return this.draw(Ne);
+  }
+  polygon(ee, Me) {
+    let Ne = this.gen.polygon(ee, Me);
+    return this.draw(Ne);
+  }
+  arc(ee, Me, Ne, Pe, Fe, Ie, Le = false, Re) {
+    let ze = this.gen.arc(ee, Me, Ne, Pe, Fe, Ie, Le, Re);
+    return this.draw(ze);
+  }
+  curve(ee, Me) {
+    let Ne = this.gen.curve(ee, Me);
+    return this.draw(Ne);
+  }
+  path(ee, Me) {
+    let Ne = this.gen.path(ee, Me);
+    return this.draw(Ne);
+  }
+}, at = {
+  canvas: (ee, Me) => new st(ee, Me),
+  svg: (ee, Me) => new ot(ee, Me),
+  generator: (ee) => new et(ee),
+  newSeed: () => et.newSeed()
+};
+export {
+  at as t
+};