@camstack/addon-pipeline-orchestrator 0.1.17 → 0.1.20

package/dist/index-C52WDzRJ.mjs

@@ -0,0 +1,3842 @@
+import { S as $, K as j, _ as V, F as u, g as T, a as Gt, b as re, U as O, c as yt, G as At, A as oe, d as Ut, e as ae, T as ct, N as B, R as jt, f as Et } from "./_CoreInternals-B7PHssO3.mjs";
+class J extends $ {
+  _sceneFunc(t) {
+    const e = j.getAngle(this.angle()), i = this.clockwise();
+    t.beginPath(), t.arc(0, 0, this.outerRadius(), 0, e, i), t.arc(0, 0, this.innerRadius(), e, 0, !i), t.closePath(), t.fillStrokeShape(this);
+  }
+  getWidth() {
+    return this.outerRadius() * 2;
+  }
+  getHeight() {
+    return this.outerRadius() * 2;
+  }
+  setWidth(t) {
+    this.outerRadius(t / 2);
+  }
+  setHeight(t) {
+    this.outerRadius(t / 2);
+  }
+  getSelfRect() {
+    const t = this.innerRadius(), e = this.outerRadius(), i = this.clockwise(), n = j.getAngle(i ? 360 - this.angle() : this.angle()), r = Math.cos(Math.min(n, Math.PI)), o = 1, s = Math.sin(Math.min(Math.max(Math.PI, n), 3 * Math.PI / 2)), a = Math.sin(Math.min(n, Math.PI / 2)), d = r * (r > 0 ? t : e), l = o * e, g = s * (s > 0 ? t : e), c = a * (a > 0 ? e : t);
+    return {
+      x: d,
+      y: i ? -1 * c : g,
+      width: l - d,
+      height: c - g
+    };
+  }
+}
+J.prototype._centroid = !0;
+J.prototype.className = "Arc";
+J.prototype._attrsAffectingSize = [
+  "innerRadius",
+  "outerRadius",
+  "angle",
+  "clockwise"
+];
+V(J);
+u.addGetterSetter(J, "innerRadius", 0, T());
+u.addGetterSetter(J, "outerRadius", 0, T());
+u.addGetterSetter(J, "angle", 0, T());
+u.addGetterSetter(J, "clockwise", !1, Gt());
+function wt(h, t, e, i, n, r, o) {
+  const s = Math.sqrt(Math.pow(e - h, 2) + Math.pow(i - t, 2)), a = Math.sqrt(Math.pow(n - e, 2) + Math.pow(r - i, 2)), d = o * s / (s + a), l = o * a / (s + a), g = e - d * (n - h), c = i - d * (r - t), p = e + l * (n - h), f = i + l * (r - t);
+  return [g, c, p, f];
+}
+function Nt(h, t) {
+  const e = h.length, i = [];
+  for (let n = 2; n < e - 2; n += 2) {
+    const r = wt(h[n - 2], h[n - 1], h[n], h[n + 1], h[n + 2], h[n + 3], t);
+    isNaN(r[0]) || (i.push(r[0]), i.push(r[1]), i.push(h[n]), i.push(h[n + 1]), i.push(r[2]), i.push(r[3]));
+  }
+  return i;
+}
+function he(h) {
+  const t = [
+    [h[0], h[2], h[4], h[6]],
+    [h[1], h[3], h[5], h[7]]
+  ], e = [];
+  for (const i of t) {
+    const n = -3 * i[0] + 9 * i[1] - 9 * i[2] + 3 * i[3];
+    if (n !== 0) {
+      const r = 6 * i[0] - 12 * i[1] + 6 * i[2], o = -3 * i[0] + 3 * i[1], s = r * r - 4 * n * o;
+      if (s >= 0) {
+        const a = Math.sqrt(s);
+        e.push((-r + a) / (2 * n)), e.push((-r - a) / (2 * n));
+      }
+    }
+  }
+  return e.filter((i) => i > 0 && i < 1).flatMap((i) => t.map((n) => {
+    const r = 1 - i;
+    return r * r * r * n[0] + 3 * r * r * i * n[1] + 3 * r * i * i * n[2] + i * i * i * n[3];
+  }));
+}
+class tt extends $ {
+  constructor(t) {
+    super(t), this.on("pointsChange.konva tensionChange.konva closedChange.konva bezierChange.konva", function() {
+      this._clearCache("tensionPoints");
+    });
+  }
+  _sceneFunc(t) {
+    const e = this.points(), i = e.length, n = this.tension(), r = this.closed(), o = this.bezier();
+    if (!i)
+      return;
+    let s = 0;
+    if (t.beginPath(), t.moveTo(e[0], e[1]), n !== 0 && i > 4) {
+      const a = this.getTensionPoints(), d = a.length;
+      for (s = r ? 0 : 4, r || t.quadraticCurveTo(a[0], a[1], a[2], a[3]); s < d - 2; )
+        t.bezierCurveTo(a[s++], a[s++], a[s++], a[s++], a[s++], a[s++]);
+      r || t.quadraticCurveTo(a[d - 2], a[d - 1], e[i - 2], e[i - 1]);
+    } else if (o)
+      for (s = 2; s < i; )
+        t.bezierCurveTo(e[s++], e[s++], e[s++], e[s++], e[s++], e[s++]);
+    else
+      for (s = 2; s < i; s += 2)
+        t.lineTo(e[s], e[s + 1]);
+    r ? (t.closePath(), t.fillStrokeShape(this)) : t.strokeShape(this);
+  }
+  getTensionPoints() {
+    return this._getCache("tensionPoints", this._getTensionPoints);
+  }
+  _getTensionPoints() {
+    return this.closed() ? this._getTensionPointsClosed() : Nt(this.points(), this.tension());
+  }
+  _getTensionPointsClosed() {
+    const t = this.points(), e = t.length, i = this.tension(), n = wt(t[e - 2], t[e - 1], t[0], t[1], t[2], t[3], i), r = wt(t[e - 4], t[e - 3], t[e - 2], t[e - 1], t[0], t[1], i), o = Nt(t, i);
+    return [n[2], n[3]].concat(o).concat([
+      r[0],
+      r[1],
+      t[e - 2],
+      t[e - 1],
+      r[2],
+      r[3],
+      n[0],
+      n[1],
+      t[0],
+      t[1]
+    ]);
+  }
+  getWidth() {
+    return this.getSelfRect().width;
+  }
+  getHeight() {
+    return this.getSelfRect().height;
+  }
+  getSelfRect() {
+    let t = this.points();
+    if (t.length < 4)
+      return {
+        x: t[0] || 0,
+        y: t[1] || 0,
+        width: 0,
+        height: 0
+      };
+    this.tension() !== 0 ? t = [
+      t[0],
+      t[1],
+      ...this._getTensionPoints(),
+      t[t.length - 2],
+      t[t.length - 1]
+    ] : this.bezier() ? t = [
+      t[0],
+      t[1],
+      ...he(this.points()),
+      t[t.length - 2],
+      t[t.length - 1]
+    ] : t = this.points();
+    let e = t[0], i = t[0], n = t[1], r = t[1], o, s;
+    for (let a = 0; a < t.length / 2; a++)
+      o = t[a * 2], s = t[a * 2 + 1], e = Math.min(e, o), i = Math.max(i, o), n = Math.min(n, s), r = Math.max(r, s);
+    return {
+      x: e,
+      y: n,
+      width: i - e,
+      height: r - n
+    };
+  }
+}
+tt.prototype.className = "Line";
+tt.prototype._attrsAffectingSize = ["points", "bezier", "tension"];
+V(tt);
+u.addGetterSetter(tt, "closed", !1);
+u.addGetterSetter(tt, "bezier", !1);
+u.addGetterSetter(tt, "tension", 0, T());
+u.addGetterSetter(tt, "points", [], re());
+const le = [
+  [],
+  [],
+  [
+    -0.5773502691896257,
+    0.5773502691896257
+  ],
+  [
+    0,
+    -0.7745966692414834,
+    0.7745966692414834
+  ],
+  [
+    -0.33998104358485626,
+    0.33998104358485626,
+    -0.8611363115940526,
+    0.8611363115940526
+  ],
+  [
+    0,
+    -0.5384693101056831,
+    0.5384693101056831,
+    -0.906179845938664,
+    0.906179845938664
+  ],
+  [
+    0.6612093864662645,
+    -0.6612093864662645,
+    -0.2386191860831969,
+    0.2386191860831969,
+    -0.932469514203152,
+    0.932469514203152
+  ],
+  [
+    0,
+    0.4058451513773972,
+    -0.4058451513773972,
+    -0.7415311855993945,
+    0.7415311855993945,
+    -0.9491079123427585,
+    0.9491079123427585
+  ],
+  [
+    -0.1834346424956498,
+    0.1834346424956498,
+    -0.525532409916329,
+    0.525532409916329,
+    -0.7966664774136267,
+    0.7966664774136267,
+    -0.9602898564975363,
+    0.9602898564975363
+  ],
+  [
+    0,
+    -0.8360311073266358,
+    0.8360311073266358,
+    -0.9681602395076261,
+    0.9681602395076261,
+    -0.3242534234038089,
+    0.3242534234038089,
+    -0.6133714327005904,
+    0.6133714327005904
+  ],
+  [
+    -0.14887433898163122,
+    0.14887433898163122,
+    -0.4333953941292472,
+    0.4333953941292472,
+    -0.6794095682990244,
+    0.6794095682990244,
+    -0.8650633666889845,
+    0.8650633666889845,
+    -0.9739065285171717,
+    0.9739065285171717
+  ],
+  [
+    0,
+    -0.26954315595234496,
+    0.26954315595234496,
+    -0.5190961292068118,
+    0.5190961292068118,
+    -0.7301520055740494,
+    0.7301520055740494,
+    -0.8870625997680953,
+    0.8870625997680953,
+    -0.978228658146057,
+    0.978228658146057
+  ],
+  [
+    -0.1252334085114689,
+    0.1252334085114689,
+    -0.3678314989981802,
+    0.3678314989981802,
+    -0.5873179542866175,
+    0.5873179542866175,
+    -0.7699026741943047,
+    0.7699026741943047,
+    -0.9041172563704749,
+    0.9041172563704749,
+    -0.9815606342467192,
+    0.9815606342467192
+  ],
+  [
+    0,
+    -0.2304583159551348,
+    0.2304583159551348,
+    -0.44849275103644687,
+    0.44849275103644687,
+    -0.6423493394403402,
+    0.6423493394403402,
+    -0.8015780907333099,
+    0.8015780907333099,
+    -0.9175983992229779,
+    0.9175983992229779,
+    -0.9841830547185881,
+    0.9841830547185881
+  ],
+  [
+    -0.10805494870734367,
+    0.10805494870734367,
+    -0.31911236892788974,
+    0.31911236892788974,
+    -0.5152486363581541,
+    0.5152486363581541,
+    -0.6872929048116855,
+    0.6872929048116855,
+    -0.827201315069765,
+    0.827201315069765,
+    -0.9284348836635735,
+    0.9284348836635735,
+    -0.9862838086968123,
+    0.9862838086968123
+  ],
+  [
+    0,
+    -0.20119409399743451,
+    0.20119409399743451,
+    -0.3941513470775634,
+    0.3941513470775634,
+    -0.5709721726085388,
+    0.5709721726085388,
+    -0.7244177313601701,
+    0.7244177313601701,
+    -0.8482065834104272,
+    0.8482065834104272,
+    -0.937273392400706,
+    0.937273392400706,
+    -0.9879925180204854,
+    0.9879925180204854
+  ],
+  [
+    -0.09501250983763744,
+    0.09501250983763744,
+    -0.2816035507792589,
+    0.2816035507792589,
+    -0.45801677765722737,
+    0.45801677765722737,
+    -0.6178762444026438,
+    0.6178762444026438,
+    -0.755404408355003,
+    0.755404408355003,
+    -0.8656312023878318,
+    0.8656312023878318,
+    -0.9445750230732326,
+    0.9445750230732326,
+    -0.9894009349916499,
+    0.9894009349916499
+  ],
+  [
+    0,
+    -0.17848418149584785,
+    0.17848418149584785,
+    -0.3512317634538763,
+    0.3512317634538763,
+    -0.5126905370864769,
+    0.5126905370864769,
+    -0.6576711592166907,
+    0.6576711592166907,
+    -0.7815140038968014,
+    0.7815140038968014,
+    -0.8802391537269859,
+    0.8802391537269859,
+    -0.9506755217687678,
+    0.9506755217687678,
+    -0.9905754753144174,
+    0.9905754753144174
+  ],
+  [
+    -0.0847750130417353,
+    0.0847750130417353,
+    -0.2518862256915055,
+    0.2518862256915055,
+    -0.41175116146284263,
+    0.41175116146284263,
+    -0.5597708310739475,
+    0.5597708310739475,
+    -0.6916870430603532,
+    0.6916870430603532,
+    -0.8037049589725231,
+    0.8037049589725231,
+    -0.8926024664975557,
+    0.8926024664975557,
+    -0.9558239495713977,
+    0.9558239495713977,
+    -0.9915651684209309,
+    0.9915651684209309
+  ],
+  [
+    0,
+    -0.16035864564022537,
+    0.16035864564022537,
+    -0.31656409996362983,
+    0.31656409996362983,
+    -0.46457074137596094,
+    0.46457074137596094,
+    -0.600545304661681,
+    0.600545304661681,
+    -0.7209661773352294,
+    0.7209661773352294,
+    -0.8227146565371428,
+    0.8227146565371428,
+    -0.9031559036148179,
+    0.9031559036148179,
+    -0.96020815213483,
+    0.96020815213483,
+    -0.9924068438435844,
+    0.9924068438435844
+  ],
+  [
+    -0.07652652113349734,
+    0.07652652113349734,
+    -0.22778585114164507,
+    0.22778585114164507,
+    -0.37370608871541955,
+    0.37370608871541955,
+    -0.5108670019508271,
+    0.5108670019508271,
+    -0.636053680726515,
+    0.636053680726515,
+    -0.7463319064601508,
+    0.7463319064601508,
+    -0.8391169718222188,
+    0.8391169718222188,
+    -0.912234428251326,
+    0.912234428251326,
+    -0.9639719272779138,
+    0.9639719272779138,
+    -0.9931285991850949,
+    0.9931285991850949
+  ],
+  [
+    0,
+    -0.1455618541608951,
+    0.1455618541608951,
+    -0.2880213168024011,
+    0.2880213168024011,
+    -0.4243421202074388,
+    0.4243421202074388,
+    -0.5516188358872198,
+    0.5516188358872198,
+    -0.6671388041974123,
+    0.6671388041974123,
+    -0.7684399634756779,
+    0.7684399634756779,
+    -0.8533633645833173,
+    0.8533633645833173,
+    -0.9200993341504008,
+    0.9200993341504008,
+    -0.9672268385663063,
+    0.9672268385663063,
+    -0.9937521706203895,
+    0.9937521706203895
+  ],
+  [
+    -0.06973927331972223,
+    0.06973927331972223,
+    -0.20786042668822127,
+    0.20786042668822127,
+    -0.34193582089208424,
+    0.34193582089208424,
+    -0.469355837986757,
+    0.469355837986757,
+    -0.5876404035069116,
+    0.5876404035069116,
+    -0.6944872631866827,
+    0.6944872631866827,
+    -0.7878168059792081,
+    0.7878168059792081,
+    -0.8658125777203002,
+    0.8658125777203002,
+    -0.926956772187174,
+    0.926956772187174,
+    -0.9700604978354287,
+    0.9700604978354287,
+    -0.9942945854823992,
+    0.9942945854823992
+  ],
+  [
+    0,
+    -0.1332568242984661,
+    0.1332568242984661,
+    -0.26413568097034495,
+    0.26413568097034495,
+    -0.3903010380302908,
+    0.3903010380302908,
+    -0.5095014778460075,
+    0.5095014778460075,
+    -0.6196098757636461,
+    0.6196098757636461,
+    -0.7186613631319502,
+    0.7186613631319502,
+    -0.8048884016188399,
+    0.8048884016188399,
+    -0.8767523582704416,
+    0.8767523582704416,
+    -0.9329710868260161,
+    0.9329710868260161,
+    -0.9725424712181152,
+    0.9725424712181152,
+    -0.9947693349975522,
+    0.9947693349975522
+  ],
+  [
+    -0.06405689286260563,
+    0.06405689286260563,
+    -0.1911188674736163,
+    0.1911188674736163,
+    -0.3150426796961634,
+    0.3150426796961634,
+    -0.4337935076260451,
+    0.4337935076260451,
+    -0.5454214713888396,
+    0.5454214713888396,
+    -0.6480936519369755,
+    0.6480936519369755,
+    -0.7401241915785544,
+    0.7401241915785544,
+    -0.820001985973903,
+    0.820001985973903,
+    -0.8864155270044011,
+    0.8864155270044011,
+    -0.9382745520027328,
+    0.9382745520027328,
+    -0.9747285559713095,
+    0.9747285559713095,
+    -0.9951872199970213,
+    0.9951872199970213
+  ]
+], de = [
+  [],
+  [],
+  [1, 1],
+  [
+    0.8888888888888888,
+    0.5555555555555556,
+    0.5555555555555556
+  ],
+  [
+    0.6521451548625461,
+    0.6521451548625461,
+    0.34785484513745385,
+    0.34785484513745385
+  ],
+  [
+    0.5688888888888889,
+    0.47862867049936647,
+    0.47862867049936647,
+    0.23692688505618908,
+    0.23692688505618908
+  ],
+  [
+    0.3607615730481386,
+    0.3607615730481386,
+    0.46791393457269104,
+    0.46791393457269104,
+    0.17132449237917036,
+    0.17132449237917036
+  ],
+  [
+    0.4179591836734694,
+    0.3818300505051189,
+    0.3818300505051189,
+    0.27970539148927664,
+    0.27970539148927664,
+    0.1294849661688697,
+    0.1294849661688697
+  ],
+  [
+    0.362683783378362,
+    0.362683783378362,
+    0.31370664587788727,
+    0.31370664587788727,
+    0.22238103445337448,
+    0.22238103445337448,
+    0.10122853629037626,
+    0.10122853629037626
+  ],
+  [
+    0.3302393550012598,
+    0.1806481606948574,
+    0.1806481606948574,
+    0.08127438836157441,
+    0.08127438836157441,
+    0.31234707704000286,
+    0.31234707704000286,
+    0.26061069640293544,
+    0.26061069640293544
+  ],
+  [
+    0.29552422471475287,
+    0.29552422471475287,
+    0.26926671930999635,
+    0.26926671930999635,
+    0.21908636251598204,
+    0.21908636251598204,
+    0.1494513491505806,
+    0.1494513491505806,
+    0.06667134430868814,
+    0.06667134430868814
+  ],
+  [
+    0.2729250867779006,
+    0.26280454451024665,
+    0.26280454451024665,
+    0.23319376459199048,
+    0.23319376459199048,
+    0.18629021092773426,
+    0.18629021092773426,
+    0.1255803694649046,
+    0.1255803694649046,
+    0.05566856711617366,
+    0.05566856711617366
+  ],
+  [
+    0.24914704581340277,
+    0.24914704581340277,
+    0.2334925365383548,
+    0.2334925365383548,
+    0.20316742672306592,
+    0.20316742672306592,
+    0.16007832854334622,
+    0.16007832854334622,
+    0.10693932599531843,
+    0.10693932599531843,
+    0.04717533638651183,
+    0.04717533638651183
+  ],
+  [
+    0.2325515532308739,
+    0.22628318026289723,
+    0.22628318026289723,
+    0.2078160475368885,
+    0.2078160475368885,
+    0.17814598076194574,
+    0.17814598076194574,
+    0.13887351021978725,
+    0.13887351021978725,
+    0.09212149983772845,
+    0.09212149983772845,
+    0.04048400476531588,
+    0.04048400476531588
+  ],
+  [
+    0.2152638534631578,
+    0.2152638534631578,
+    0.2051984637212956,
+    0.2051984637212956,
+    0.18553839747793782,
+    0.18553839747793782,
+    0.15720316715819355,
+    0.15720316715819355,
+    0.12151857068790319,
+    0.12151857068790319,
+    0.08015808715976021,
+    0.08015808715976021,
+    0.03511946033175186,
+    0.03511946033175186
+  ],
+  [
+    0.2025782419255613,
+    0.19843148532711158,
+    0.19843148532711158,
+    0.1861610000155622,
+    0.1861610000155622,
+    0.16626920581699392,
+    0.16626920581699392,
+    0.13957067792615432,
+    0.13957067792615432,
+    0.10715922046717194,
+    0.10715922046717194,
+    0.07036604748810812,
+    0.07036604748810812,
+    0.03075324199611727,
+    0.03075324199611727
+  ],
+  [
+    0.1894506104550685,
+    0.1894506104550685,
+    0.18260341504492358,
+    0.18260341504492358,
+    0.16915651939500254,
+    0.16915651939500254,
+    0.14959598881657674,
+    0.14959598881657674,
+    0.12462897125553388,
+    0.12462897125553388,
+    0.09515851168249279,
+    0.09515851168249279,
+    0.062253523938647894,
+    0.062253523938647894,
+    0.027152459411754096,
+    0.027152459411754096
+  ],
+  [
+    0.17944647035620653,
+    0.17656270536699264,
+    0.17656270536699264,
+    0.16800410215645004,
+    0.16800410215645004,
+    0.15404576107681028,
+    0.15404576107681028,
+    0.13513636846852548,
+    0.13513636846852548,
+    0.11188384719340397,
+    0.11188384719340397,
+    0.08503614831717918,
+    0.08503614831717918,
+    0.0554595293739872,
+    0.0554595293739872,
+    0.02414830286854793,
+    0.02414830286854793
+  ],
+  [
+    0.1691423829631436,
+    0.1691423829631436,
+    0.16427648374583273,
+    0.16427648374583273,
+    0.15468467512626524,
+    0.15468467512626524,
+    0.14064291467065065,
+    0.14064291467065065,
+    0.12255520671147846,
+    0.12255520671147846,
+    0.10094204410628717,
+    0.10094204410628717,
+    0.07642573025488905,
+    0.07642573025488905,
+    0.0497145488949698,
+    0.0497145488949698,
+    0.02161601352648331,
+    0.02161601352648331
+  ],
+  [
+    0.1610544498487837,
+    0.15896884339395434,
+    0.15896884339395434,
+    0.15276604206585967,
+    0.15276604206585967,
+    0.1426067021736066,
+    0.1426067021736066,
+    0.12875396253933621,
+    0.12875396253933621,
+    0.11156664554733399,
+    0.11156664554733399,
+    0.09149002162245,
+    0.09149002162245,
+    0.06904454273764123,
+    0.06904454273764123,
+    0.0448142267656996,
+    0.0448142267656996,
+    0.019461788229726478,
+    0.019461788229726478
+  ],
+  [
+    0.15275338713072584,
+    0.15275338713072584,
+    0.14917298647260374,
+    0.14917298647260374,
+    0.14209610931838204,
+    0.14209610931838204,
+    0.13168863844917664,
+    0.13168863844917664,
+    0.11819453196151841,
+    0.11819453196151841,
+    0.10193011981724044,
+    0.10193011981724044,
+    0.08327674157670475,
+    0.08327674157670475,
+    0.06267204833410907,
+    0.06267204833410907,
+    0.04060142980038694,
+    0.04060142980038694,
+    0.017614007139152118,
+    0.017614007139152118
+  ],
+  [
+    0.14608113364969041,
+    0.14452440398997005,
+    0.14452440398997005,
+    0.13988739479107315,
+    0.13988739479107315,
+    0.13226893863333747,
+    0.13226893863333747,
+    0.12183141605372853,
+    0.12183141605372853,
+    0.10879729916714838,
+    0.10879729916714838,
+    0.09344442345603386,
+    0.09344442345603386,
+    0.0761001136283793,
+    0.0761001136283793,
+    0.057134425426857205,
+    0.057134425426857205,
+    0.036953789770852494,
+    0.036953789770852494,
+    0.016017228257774335,
+    0.016017228257774335
+  ],
+  [
+    0.13925187285563198,
+    0.13925187285563198,
+    0.13654149834601517,
+    0.13654149834601517,
+    0.13117350478706238,
+    0.13117350478706238,
+    0.12325237681051242,
+    0.12325237681051242,
+    0.11293229608053922,
+    0.11293229608053922,
+    0.10041414444288096,
+    0.10041414444288096,
+    0.08594160621706773,
+    0.08594160621706773,
+    0.06979646842452049,
+    0.06979646842452049,
+    0.052293335152683286,
+    0.052293335152683286,
+    0.03377490158481415,
+    0.03377490158481415,
+    0.0146279952982722,
+    0.0146279952982722
+  ],
+  [
+    0.13365457218610619,
+    0.1324620394046966,
+    0.1324620394046966,
+    0.12890572218808216,
+    0.12890572218808216,
+    0.12304908430672953,
+    0.12304908430672953,
+    0.11499664022241136,
+    0.11499664022241136,
+    0.10489209146454141,
+    0.10489209146454141,
+    0.09291576606003515,
+    0.09291576606003515,
+    0.07928141177671895,
+    0.07928141177671895,
+    0.06423242140852585,
+    0.06423242140852585,
+    0.04803767173108467,
+    0.04803767173108467,
+    0.030988005856979445,
+    0.030988005856979445,
+    0.013411859487141771,
+    0.013411859487141771
+  ],
+  [
+    0.12793819534675216,
+    0.12793819534675216,
+    0.1258374563468283,
+    0.1258374563468283,
+    0.12167047292780339,
+    0.12167047292780339,
+    0.1155056680537256,
+    0.1155056680537256,
+    0.10744427011596563,
+    0.10744427011596563,
+    0.09761865210411388,
+    0.09761865210411388,
+    0.08619016153195327,
+    0.08619016153195327,
+    0.0733464814110803,
+    0.0733464814110803,
+    0.05929858491543678,
+    0.05929858491543678,
+    0.04427743881741981,
+    0.04427743881741981,
+    0.028531388628933663,
+    0.028531388628933663,
+    0.0123412297999872,
+    0.0123412297999872
+  ]
+], ce = [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]], It = (h, t, e) => {
+  let i, n;
+  const o = e / 2;
+  i = 0;
+  for (let s = 0; s < 20; s++)
+    n = o * le[20][s] + o, i += de[20][s] * fe(h, t, n);
+  return o * i;
+}, Ft = (h, t, e) => {
+  e === void 0 && (e = 1);
+  const i = h[0] - 2 * h[1] + h[2], n = t[0] - 2 * t[1] + t[2], r = 2 * h[1] - 2 * h[0], o = 2 * t[1] - 2 * t[0], s = 4 * (i * i + n * n), a = 4 * (i * r + n * o), d = r * r + o * o;
+  if (s === 0)
+    return e * Math.sqrt(Math.pow(h[2] - h[0], 2) + Math.pow(t[2] - t[0], 2));
+  const l = a / (2 * s), g = d / s, c = e + l, p = g - l * l, f = c * c + p > 0 ? Math.sqrt(c * c + p) : 0, S = l * l + p > 0 ? Math.sqrt(l * l + p) : 0, _ = l + Math.sqrt(l * l + p) !== 0 ? p * Math.log(Math.abs((c + f) / (l + S))) : 0;
+  return Math.sqrt(s) / 2 * (c * f - l * S + _);
+};
+function fe(h, t, e) {
+  const i = Tt(1, e, h), n = Tt(1, e, t), r = i * i + n * n;
+  return Math.sqrt(r);
+}
+const Tt = (h, t, e) => {
+  const i = e.length - 1;
+  let n, r;
+  if (i === 0)
+    return 0;
+  if (h === 0) {
+    r = 0;
+    for (let o = 0; o <= i; o++)
+      r += ce[i][o] * Math.pow(1 - t, i - o) * Math.pow(t, o) * e[o];
+    return r;
+  } else {
+    n = new Array(i);
+    for (let o = 0; o < i; o++)
+      n[o] = i * (e[o + 1] - e[o]);
+    return Tt(h - 1, t, n);
+  }
+}, Bt = (h, t, e) => {
+  let i = 1, n = h / t, r = (h - e(n)) / t, o = 0;
+  for (; i > 1e-3; ) {
+    const s = e(n + r), a = Math.abs(h - s) / t;
+    if (a < i)
+      i = a, n += r;
+    else {
+      const d = e(n - r), l = Math.abs(h - d) / t;
+      l < i ? (i = l, n -= r) : r /= 2;
+    }
+    if (o++, o > 500)
+      break;
+  }
+  return n;
+};
+class H extends $ {
+  constructor(t) {
+    super(t), this.dataArray = [], this.pathLength = 0, this._readDataAttribute(), this.on("dataChange.konva", function() {
+      this._readDataAttribute();
+    });
+  }
+  _readDataAttribute() {
+    this.dataArray = H.parsePathData(this.data()), this.pathLength = H.getPathLength(this.dataArray);
+  }
+  _sceneFunc(t) {
+    const e = this.dataArray;
+    t.beginPath();
+    let i = !1;
+    for (let n = 0; n < e.length; n++) {
+      const r = e[n].command, o = e[n].points;
+      switch (r) {
+        case "L":
+          t.lineTo(o[0], o[1]);
+          break;
+        case "M":
+          t.moveTo(o[0], o[1]);
+          break;
+        case "C":
+          t.bezierCurveTo(o[0], o[1], o[2], o[3], o[4], o[5]);
+          break;
+        case "Q":
+          t.quadraticCurveTo(o[0], o[1], o[2], o[3]);
+          break;
+        case "A":
+          const s = o[0], a = o[1], d = o[2], l = o[3], g = o[4], c = o[5], p = o[6], f = o[7], S = d > l ? d : l, _ = d > l ? 1 : d / l, b = d > l ? l / d : 1;
+          t.translate(s, a), t.rotate(p), t.scale(_, b), t.arc(0, 0, S, g, g + c, 1 - f), t.scale(1 / _, 1 / b), t.rotate(-p), t.translate(-s, -a);
+          break;
+        case "z":
+          i = !0, t.closePath();
+          break;
+      }
+    }
+    !i && !this.hasFill() ? t.strokeShape(this) : t.fillStrokeShape(this);
+  }
+  getSelfRect() {
+    let t = [];
+    this.dataArray.forEach(function(a) {
+      if (a.command === "A") {
+        const d = a.points[4], l = a.points[5], g = a.points[4] + l;
+        let c = Math.PI / 180;
+        if (Math.abs(d - g) < c && (c = Math.abs(d - g)), l < 0)
+          for (let p = d - c; p > g; p -= c) {
+            const f = H.getPointOnEllipticalArc(a.points[0], a.points[1], a.points[2], a.points[3], p, 0);
+            t.push(f.x, f.y);
+          }
+        else
+          for (let p = d + c; p < g; p += c) {
+            const f = H.getPointOnEllipticalArc(a.points[0], a.points[1], a.points[2], a.points[3], p, 0);
+            t.push(f.x, f.y);
+          }
+      } else if (a.command === "C")
+        for (let d = 0; d <= 1; d += 0.01) {
+          const l = H.getPointOnCubicBezier(d, a.start.x, a.start.y, a.points[0], a.points[1], a.points[2], a.points[3], a.points[4], a.points[5]);
+          t.push(l.x, l.y);
+        }
+      else
+        t = t.concat(a.points);
+    });
+    let e = t[0], i = t[0], n = t[1], r = t[1], o, s;
+    for (let a = 0; a < t.length / 2; a++)
+      o = t[a * 2], s = t[a * 2 + 1], isNaN(o) || (e = Math.min(e, o), i = Math.max(i, o)), isNaN(s) || (n = Math.min(n, s), r = Math.max(r, s));
+    return {
+      x: e,
+      y: n,
+      width: i - e,
+      height: r - n
+    };
+  }
+  getLength() {
+    return this.pathLength;
+  }
+  getPointAtLength(t) {
+    return H.getPointAtLengthOfDataArray(t, this.dataArray);
+  }
+  static getLineLength(t, e, i, n) {
+    return Math.sqrt((i - t) * (i - t) + (n - e) * (n - e));
+  }
+  static getPathLength(t) {
+    let e = 0;
+    for (let i = 0; i < t.length; ++i)
+      e += t[i].pathLength;
+    return e;
+  }
+  static getPointAtLengthOfDataArray(t, e) {
+    let i, n = 0, r = e.length;
+    if (!r)
+      return null;
+    for (; n < r && t > e[n].pathLength; )
+      t -= e[n].pathLength, ++n;
+    if (n === r)
+      return i = e[n - 1].points.slice(-2), {
+        x: i[0],
+        y: i[1]
+      };
+    if (t < 0.01)
+      return e[n].command === "M" ? (i = e[n].points.slice(0, 2), {
+        x: i[0],
+        y: i[1]
+      }) : {
+        x: e[n].start.x,
+        y: e[n].start.y
+      };
+    const o = e[n], s = o.points;
+    switch (o.command) {
+      case "L":
+        return H.getPointOnLine(t, o.start.x, o.start.y, s[0], s[1]);
+      case "C":
+        return H.getPointOnCubicBezier(Bt(t, H.getPathLength(e), (S) => It([o.start.x, s[0], s[2], s[4]], [o.start.y, s[1], s[3], s[5]], S)), o.start.x, o.start.y, s[0], s[1], s[2], s[3], s[4], s[5]);
+      case "Q":
+        return H.getPointOnQuadraticBezier(Bt(t, H.getPathLength(e), (S) => Ft([o.start.x, s[0], s[2]], [o.start.y, s[1], s[3]], S)), o.start.x, o.start.y, s[0], s[1], s[2], s[3]);
+      case "A":
+        const a = s[0], d = s[1], l = s[2], g = s[3], c = s[5], p = s[6];
+        let f = s[4];
+        return f += c * t / o.pathLength, H.getPointOnEllipticalArc(a, d, l, g, f, p);
+    }
+    return null;
+  }
+  static getPointOnLine(t, e, i, n, r, o, s) {
+    o = o ?? e, s = s ?? i;
+    const a = this.getLineLength(e, i, n, r);
+    if (a < 1e-10)
+      return { x: e, y: i };
+    if (n === e)
+      return { x: o, y: s + (r > i ? t : -t) };
+    const d = (r - i) / (n - e), l = Math.sqrt(t * t / (1 + d * d)) * (n < e ? -1 : 1), g = d * l;
+    if (Math.abs(s - i - d * (o - e)) < 1e-10)
+      return { x: o + l, y: s + g };
+    const c = ((o - e) * (n - e) + (s - i) * (r - i)) / (a * a), p = e + c * (n - e), f = i + c * (r - i), S = this.getLineLength(o, s, p, f), _ = Math.sqrt(t * t - S * S), b = Math.sqrt(_ * _ / (1 + d * d)) * (n < e ? -1 : 1), m = d * b;
+    return { x: p + b, y: f + m };
+  }
+  static getPointOnCubicBezier(t, e, i, n, r, o, s, a, d) {
+    function l(_) {
+      return _ * _ * _;
+    }
+    function g(_) {
+      return 3 * _ * _ * (1 - _);
+    }
+    function c(_) {
+      return 3 * _ * (1 - _) * (1 - _);
+    }
+    function p(_) {
+      return (1 - _) * (1 - _) * (1 - _);
+    }
+    const f = a * l(t) + o * g(t) + n * c(t) + e * p(t), S = d * l(t) + s * g(t) + r * c(t) + i * p(t);
+    return { x: f, y: S };
+  }
+  static getPointOnQuadraticBezier(t, e, i, n, r, o, s) {
+    function a(p) {
+      return p * p;
+    }
+    function d(p) {
+      return 2 * p * (1 - p);
+    }
+    function l(p) {
+      return (1 - p) * (1 - p);
+    }
+    const g = o * a(t) + n * d(t) + e * l(t), c = s * a(t) + r * d(t) + i * l(t);
+    return { x: g, y: c };
+  }
+  static getPointOnEllipticalArc(t, e, i, n, r, o) {
+    const s = Math.cos(o), a = Math.sin(o), d = {
+      x: i * Math.cos(r),
+      y: n * Math.sin(r)
+    };
+    return {
+      x: t + (d.x * s - d.y * a),
+      y: e + (d.x * a + d.y * s)
+    };
+  }
+  static parsePathData(t) {
+    if (!t)
+      return [];
+    let e = t;
+    const i = [
+      "m",
+      "M",
+      "l",
+      "L",
+      "v",
+      "V",
+      "h",
+      "H",
+      "z",
+      "Z",
+      "c",
+      "C",
+      "q",
+      "Q",
+      "t",
+      "T",
+      "s",
+      "S",
+      "a",
+      "A"
+    ];
+    e = e.replace(new RegExp(" ", "g"), ",");
+    for (let g = 0; g < i.length; g++)
+      e = e.replace(new RegExp(i[g], "g"), "|" + i[g]);
+    const n = e.split("|"), r = [], o = [];
+    let s = 0, a = 0;
+    const d = /([-+]?((\d+\.\d+)|((\d+)|(\.\d+)))(?:e[-+]?\d+)?)/gi;
+    let l;
+    for (let g = 1; g < n.length; g++) {
+      let c = n[g], p = c.charAt(0);
+      for (c = c.slice(1), o.length = 0; l = d.exec(c); )
+        o.push(l[0]);
+      let f = [], S = p === "A" || p === "a" ? 0 : -1;
+      for (let _ = 0, b = o.length; _ < b; _++) {
+        const m = o[_];
+        if (m === "00") {
+          f.push(0, 0), S >= 0 && (S += 2, S >= 7 && (S -= 7));
+          continue;
+        }
+        if (S >= 0) {
+          if (S === 3) {
+            if (/^[01]{2}\d+(?:\.\d+)?$/.test(m)) {
+              f.push(parseInt(m[0], 10)), f.push(parseInt(m[1], 10)), f.push(parseFloat(m.slice(2))), S += 3, S >= 7 && (S -= 7);
+              continue;
+            }
+            if (m === "11" || m === "10" || m === "01") {
+              f.push(parseInt(m[0], 10)), f.push(parseInt(m[1], 10)), S += 2, S >= 7 && (S -= 7);
+              continue;
+            }
+            if (m === "0" || m === "1") {
+              f.push(parseInt(m, 10)), S += 1, S >= 7 && (S -= 7);
+              continue;
+            }
+          } else if (S === 4) {
+            if (/^[01]\d+(?:\.\d+)?$/.test(m)) {
+              f.push(parseInt(m[0], 10)), f.push(parseFloat(m.slice(1))), S += 2, S >= 7 && (S -= 7);
+              continue;
+            }
+            if (m === "0" || m === "1") {
+              f.push(parseInt(m, 10)), S += 1, S >= 7 && (S -= 7);
+              continue;
+            }
+          }
+          const x = parseFloat(m);
+          isNaN(x) ? f.push(0) : f.push(x), S += 1, S >= 7 && (S -= 7);
+        } else {
+          const x = parseFloat(m);
+          isNaN(x) ? f.push(0) : f.push(x);
+        }
+      }
+      for (; f.length > 0 && !isNaN(f[0]); ) {
+        let _ = "", b = [];
+        const m = s, x = a;
+        let y, v, M, C, A, k, G, I, P, F;
+        switch (p) {
+          case "l":
+            s += f.shift(), a += f.shift(), _ = "L", b.push(s, a);
+            break;
+          case "L":
+            s = f.shift(), a = f.shift(), b.push(s, a);
+            break;
+          case "m":
+            const E = f.shift(), L = f.shift();
+            if (s += E, a += L, _ = "M", r.length > 2 && r[r.length - 1].command === "z") {
+              for (let w = r.length - 2; w >= 0; w--)
+                if (r[w].command === "M") {
+                  s = r[w].points[0] + E, a = r[w].points[1] + L;
+                  break;
+                }
+            }
+            b.push(s, a), p = "l";
+            break;
+          case "M":
+            s = f.shift(), a = f.shift(), _ = "M", b.push(s, a), p = "L";
+            break;
+          case "h":
+            s += f.shift(), _ = "L", b.push(s, a);
+            break;
+          case "H":
+            s = f.shift(), _ = "L", b.push(s, a);
+            break;
+          case "v":
+            a += f.shift(), _ = "L", b.push(s, a);
+            break;
+          case "V":
+            a = f.shift(), _ = "L", b.push(s, a);
+            break;
+          case "C":
+            b.push(f.shift(), f.shift(), f.shift(), f.shift()), s = f.shift(), a = f.shift(), b.push(s, a);
+            break;
+          case "c":
+            b.push(s + f.shift(), a + f.shift(), s + f.shift(), a + f.shift()), s += f.shift(), a += f.shift(), _ = "C", b.push(s, a);
+            break;
+          case "S":
+            v = s, M = a, y = r[r.length - 1], y.command === "C" && (v = s + (s - y.points[2]), M = a + (a - y.points[3])), b.push(v, M, f.shift(), f.shift()), s = f.shift(), a = f.shift(), _ = "C", b.push(s, a);
+            break;
+          case "s":
+            v = s, M = a, y = r[r.length - 1], y.command === "C" && (v = s + (s - y.points[2]), M = a + (a - y.points[3])), b.push(v, M, s + f.shift(), a + f.shift()), s += f.shift(), a += f.shift(), _ = "C", b.push(s, a);
+            break;
+          case "Q":
+            b.push(f.shift(), f.shift()), s = f.shift(), a = f.shift(), b.push(s, a);
+            break;
+          case "q":
+            b.push(s + f.shift(), a + f.shift()), s += f.shift(), a += f.shift(), _ = "Q", b.push(s, a);
+            break;
+          case "T":
+            v = s, M = a, y = r[r.length - 1], y.command === "Q" && (v = s + (s - y.points[0]), M = a + (a - y.points[1])), s = f.shift(), a = f.shift(), _ = "Q", b.push(v, M, s, a);
+            break;
+          case "t":
+            v = s, M = a, y = r[r.length - 1], y.command === "Q" && (v = s + (s - y.points[0]), M = a + (a - y.points[1])), s += f.shift(), a += f.shift(), _ = "Q", b.push(v, M, s, a);
+            break;
+          case "A":
+            C = f.shift(), A = f.shift(), k = f.shift(), G = f.shift(), I = f.shift(), P = s, F = a, s = f.shift(), a = f.shift(), _ = "A", b = this.convertEndpointToCenterParameterization(P, F, s, a, G, I, C, A, k);
+            break;
+          case "a":
+            C = f.shift(), A = f.shift(), k = f.shift(), G = f.shift(), I = f.shift(), P = s, F = a, s += f.shift(), a += f.shift(), _ = "A", b = this.convertEndpointToCenterParameterization(P, F, s, a, G, I, C, A, k);
+            break;
+        }
+        r.push({
+          command: _ || p,
+          points: b,
+          start: {
+            x: m,
+            y: x
+          },
+          pathLength: this.calcLength(m, x, _ || p, b)
+        });
+      }
+      (p === "z" || p === "Z") && r.push({
+        command: "z",
+        points: [],
+        start: void 0,
+        pathLength: 0
+      });
+    }
+    return r;
+  }
+  static calcLength(t, e, i, n) {
+    let r, o, s, a;
+    const d = H;
+    switch (i) {
+      case "L":
+        return d.getLineLength(t, e, n[0], n[1]);
+      case "C":
+        return It([t, n[0], n[2], n[4]], [e, n[1], n[3], n[5]], 1);
+      case "Q":
+        return Ft([t, n[0], n[2]], [e, n[1], n[3]], 1);
+      case "A":
+        r = 0;
+        const l = n[4], g = n[5], c = n[4] + g;
+        let p = Math.PI / 180;
+        if (Math.abs(l - c) < p && (p = Math.abs(l - c)), o = d.getPointOnEllipticalArc(n[0], n[1], n[2], n[3], l, 0), g < 0)
+          for (a = l - p; a > c; a -= p)
+            s = d.getPointOnEllipticalArc(n[0], n[1], n[2], n[3], a, 0), r += d.getLineLength(o.x, o.y, s.x, s.y), o = s;
+        else
+          for (a = l + p; a < c; a += p)
+            s = d.getPointOnEllipticalArc(n[0], n[1], n[2], n[3], a, 0), r += d.getLineLength(o.x, o.y, s.x, s.y), o = s;
+        return s = d.getPointOnEllipticalArc(n[0], n[1], n[2], n[3], c, 0), r += d.getLineLength(o.x, o.y, s.x, s.y), r;
+    }
+    return 0;
+  }
+  static convertEndpointToCenterParameterization(t, e, i, n, r, o, s, a, d) {
+    const l = d * (Math.PI / 180), g = Math.cos(l) * (t - i) / 2 + Math.sin(l) * (e - n) / 2, c = -1 * Math.sin(l) * (t - i) / 2 + Math.cos(l) * (e - n) / 2, p = g * g / (s * s) + c * c / (a * a);
+    p > 1 && (s *= Math.sqrt(p), a *= Math.sqrt(p));
+    let f = Math.sqrt((s * s * (a * a) - s * s * (c * c) - a * a * (g * g)) / (s * s * (c * c) + a * a * (g * g)));
+    r === o && (f *= -1), isNaN(f) && (f = 0);
+    const S = f * s * c / a, _ = f * -a * g / s, b = (t + i) / 2 + Math.cos(l) * S - Math.sin(l) * _, m = (e + n) / 2 + Math.sin(l) * S + Math.cos(l) * _, x = function(G) {
+      return Math.sqrt(G[0] * G[0] + G[1] * G[1]);
+    }, y = function(G, I) {
+      return (G[0] * I[0] + G[1] * I[1]) / (x(G) * x(I));
+    }, v = function(G, I) {
+      return (G[0] * I[1] < G[1] * I[0] ? -1 : 1) * Math.acos(y(G, I));
+    }, M = v([1, 0], [(g - S) / s, (c - _) / a]), C = [(g - S) / s, (c - _) / a], A = [(-1 * g - S) / s, (-1 * c - _) / a];
+    let k = v(C, A);
+    return y(C, A) <= -1 && (k = Math.PI), y(C, A) >= 1 && (k = 0), o === 0 && k > 0 && (k = k - 2 * Math.PI), o === 1 && k < 0 && (k = k + 2 * Math.PI), [b, m, s, a, M, k, l, o];
+  }
+}
+H.prototype.className = "Path";
+H.prototype._attrsAffectingSize = ["data"];
+V(H);
+u.addGetterSetter(H, "data");
+class ot extends tt {
+  _sceneFunc(t) {
+    super._sceneFunc(t);
+    const e = Math.PI * 2, i = this.points();
+    let n = i;
+    const r = this.tension() !== 0 && i.length > 4;
+    r && (n = this.getTensionPoints());
+    const o = this.pointerLength(), s = i.length;
+    let a, d;
+    if (r) {
+      const c = [
+        n[n.length - 4],
+        n[n.length - 3],
+        n[n.length - 2],
+        n[n.length - 1],
+        i[s - 2],
+        i[s - 1]
+      ], p = H.calcLength(n[n.length - 4], n[n.length - 3], "C", c), f = H.getPointOnQuadraticBezier(Math.min(1, 1 - o / p), c[0], c[1], c[2], c[3], c[4], c[5]);
+      a = i[s - 2] - f.x, d = i[s - 1] - f.y;
+    } else
+      a = i[s - 2] - i[s - 4], d = i[s - 1] - i[s - 3];
+    const l = (Math.atan2(d, a) + e) % e, g = this.pointerWidth();
+    this.pointerAtEnding() && (t.save(), t.beginPath(), t.translate(i[s - 2], i[s - 1]), t.rotate(l), t.moveTo(0, 0), t.lineTo(-o, g / 2), t.lineTo(-o, -g / 2), t.closePath(), t.restore(), this.__fillStroke(t)), this.pointerAtBeginning() && (t.save(), t.beginPath(), t.translate(i[0], i[1]), r ? (a = (n[0] + n[2]) / 2 - i[0], d = (n[1] + n[3]) / 2 - i[1]) : (a = i[2] - i[0], d = i[3] - i[1]), t.rotate((Math.atan2(-d, -a) + e) % e), t.moveTo(0, 0), t.lineTo(-o, g / 2), t.lineTo(-o, -g / 2), t.closePath(), t.restore(), this.__fillStroke(t));
+  }
+  __fillStroke(t) {
+    const e = this.dashEnabled();
+    e && (this.attrs.dashEnabled = !1, t.setLineDash([])), t.fillStrokeShape(this), e && (this.attrs.dashEnabled = !0);
+  }
+  getSelfRect() {
+    const t = super.getSelfRect(), e = this.pointerWidth() / 2;
+    return {
+      x: t.x,
+      y: t.y - e,
+      width: t.width,
+      height: t.height + e * 2
+    };
+  }
+}
+ot.prototype.className = "Arrow";
+V(ot);
+u.addGetterSetter(ot, "pointerLength", 10, T());
+u.addGetterSetter(ot, "pointerWidth", 10, T());
+u.addGetterSetter(ot, "pointerAtBeginning", !1);
+u.addGetterSetter(ot, "pointerAtEnding", !0);
+class dt extends $ {
+  _sceneFunc(t) {
+    t.beginPath(), t.arc(0, 0, this.attrs.radius || 0, 0, Math.PI * 2, !1), t.closePath(), t.fillStrokeShape(this);
+  }
+  getWidth() {
+    return this.radius() * 2;
+  }
+  getHeight() {
+    return this.radius() * 2;
+  }
+  setWidth(t) {
+    this.radius() !== t / 2 && this.radius(t / 2);
+  }
+  setHeight(t) {
+    this.radius() !== t / 2 && this.radius(t / 2);
+  }
+}
+dt.prototype._centroid = !0;
+dt.prototype.className = "Circle";
+dt.prototype._attrsAffectingSize = ["radius"];
+V(dt);
+u.addGetterSetter(dt, "radius", 0, T());
+class nt extends $ {
+  _sceneFunc(t) {
+    const e = this.radiusX(), i = this.radiusY();
+    t.beginPath(), t.save(), e !== i && t.scale(1, i / e), t.arc(0, 0, e, 0, Math.PI * 2, !1), t.restore(), t.closePath(), t.fillStrokeShape(this);
+  }
+  getWidth() {
+    return this.radiusX() * 2;
+  }
+  getHeight() {
+    return this.radiusY() * 2;
+  }
+  setWidth(t) {
+    this.radiusX(t / 2);
+  }
+  setHeight(t) {
+    this.radiusY(t / 2);
+  }
+}
+nt.prototype.className = "Ellipse";
+nt.prototype._centroid = !0;
+nt.prototype._attrsAffectingSize = ["radiusX", "radiusY"];
+V(nt);
+u.addComponentsGetterSetter(nt, "radius", ["x", "y"]);
+u.addGetterSetter(nt, "radiusX", 0, T());
+u.addGetterSetter(nt, "radiusY", 0, T());
+class K extends $ {
+  constructor(t) {
+    super(t), this._loadListener = () => {
+      this._requestDraw();
+    }, this.on("imageChange.konva", (e) => {
+      this._removeImageLoad(e.oldVal), this._setImageLoad();
+    }), this._setImageLoad();
+  }
+  _setImageLoad() {
+    const t = this.image();
+    t && t.complete || t && t.readyState === 4 || t && t.addEventListener && t.addEventListener("load", this._loadListener);
+  }
+  _removeImageLoad(t) {
+    t && t.removeEventListener && t.removeEventListener("load", this._loadListener);
+  }
+  destroy() {
+    return this._removeImageLoad(this.image()), super.destroy(), this;
+  }
+  _useBufferCanvas() {
+    const t = !!this.cornerRadius(), e = this.hasShadow();
+    return t && e ? !0 : super._useBufferCanvas(!0);
+  }
+  _sceneFunc(t) {
+    const e = this.getWidth(), i = this.getHeight(), n = this.cornerRadius(), r = this.attrs.image;
+    let o;
+    if (r) {
+      const s = this.attrs.cropWidth, a = this.attrs.cropHeight;
+      s && a ? o = [
+        r,
+        this.cropX(),
+        this.cropY(),
+        s,
+        a,
+        0,
+        0,
+        e,
+        i
+      ] : o = [r, 0, 0, e, i];
+    }
+    (this.hasFill() || this.hasStroke() || n) && (t.beginPath(), n ? O.drawRoundedRectPath(t, e, i, n) : t.rect(0, 0, e, i), t.closePath(), t.fillStrokeShape(this)), r && (n && t.clip(), t.drawImage.apply(t, o));
+  }
+  _hitFunc(t) {
+    const e = this.width(), i = this.height(), n = this.cornerRadius();
+    t.beginPath(), n ? O.drawRoundedRectPath(t, e, i, n) : t.rect(0, 0, e, i), t.closePath(), t.fillStrokeShape(this);
+  }
+  getWidth() {
+    var t, e, i;
+    return (i = (t = this.attrs.width) !== null && t !== void 0 ? t : (e = this.image()) === null || e === void 0 ? void 0 : e.width) !== null && i !== void 0 ? i : 0;
+  }
+  getHeight() {
+    var t, e, i;
+    return (i = (t = this.attrs.height) !== null && t !== void 0 ? t : (e = this.image()) === null || e === void 0 ? void 0 : e.height) !== null && i !== void 0 ? i : 0;
+  }
+  static fromURL(t, e, i = null) {
+    const n = O.createImageElement();
+    n.onload = function() {
+      const r = new K({
+        image: n
+      });
+      e(r);
+    }, n.onerror = i, n.crossOrigin = "Anonymous", n.src = t;
+  }
+}
+K.prototype.className = "Image";
+K.prototype._attrsAffectingSize = ["image"];
+V(K);
+u.addGetterSetter(K, "cornerRadius", 0, yt(4));
+u.addGetterSetter(K, "image");
+u.addComponentsGetterSetter(K, "crop", ["x", "y", "width", "height"]);
+u.addGetterSetter(K, "cropX", 0, T());
+u.addGetterSetter(K, "cropY", 0, T());
+u.addGetterSetter(K, "cropWidth", 0, T());
+u.addGetterSetter(K, "cropHeight", 0, T());
+const Vt = [
+  "fontFamily",
+  "fontSize",
+  "fontStyle",
+  "padding",
+  "lineHeight",
+  "text",
+  "width",
+  "height",
+  "pointerDirection",
+  "pointerWidth",
+  "pointerHeight"
+], ge = "Change.konva", ue = "none", Ct = "up", kt = "right", Rt = "down", Pt = "left", pe = Vt.length;
+class Ot extends At {
+  constructor(t) {
+    super(t), this.on("add.konva", function(e) {
+      this._addListeners(e.child), this._sync();
+    });
+  }
+  getText() {
+    return this.find("Text")[0];
+  }
+  getTag() {
+    return this.find("Tag")[0];
+  }
+  _addListeners(t) {
+    let e = this, i;
+    const n = function() {
+      e._sync();
+    };
+    for (i = 0; i < pe; i++)
+      t.on(Vt[i] + ge, n);
+  }
+  getWidth() {
+    return this.getText().width();
+  }
+  getHeight() {
+    return this.getText().height();
+  }
+  _sync() {
+    let t = this.getText(), e = this.getTag(), i, n, r, o, s, a, d;
+    if (t && e) {
+      switch (i = t.width(), n = t.height(), r = e.pointerDirection(), o = e.pointerWidth(), d = e.pointerHeight(), s = 0, a = 0, r) {
+        case Ct:
+          s = i / 2, a = -1 * d;
+          break;
+        case kt:
+          s = i + o, a = n / 2;
+          break;
+        case Rt:
+          s = i / 2, a = n + d;
+          break;
+        case Pt:
+          s = -1 * o, a = n / 2;
+          break;
+      }
+      e.setAttrs({
+        x: -1 * s,
+        y: -1 * a,
+        width: i,
+        height: n
+      }), t.setAttrs({
+        x: -1 * s,
+        y: -1 * a
+      });
+    }
+  }
+}
+Ot.prototype.className = "Label";
+V(Ot);
+class at extends $ {
+  _sceneFunc(t) {
+    const e = this.width(), i = this.height(), n = this.pointerDirection(), r = this.pointerWidth(), o = this.pointerHeight(), s = this.cornerRadius();
+    let a = 0, d = 0, l = 0, g = 0;
+    typeof s == "number" ? a = d = l = g = Math.min(s, e / 2, i / 2) : (a = Math.min(s[0] || 0, e / 2, i / 2), d = Math.min(s[1] || 0, e / 2, i / 2), g = Math.min(s[2] || 0, e / 2, i / 2), l = Math.min(s[3] || 0, e / 2, i / 2)), t.beginPath(), t.moveTo(a, 0), n === Ct && (t.lineTo((e - r) / 2, 0), t.lineTo(e / 2, -1 * o), t.lineTo((e + r) / 2, 0)), t.lineTo(e - d, 0), t.arc(e - d, d, d, Math.PI * 3 / 2, 0, !1), n === kt && (t.lineTo(e, (i - o) / 2), t.lineTo(e + r, i / 2), t.lineTo(e, (i + o) / 2)), t.lineTo(e, i - g), t.arc(e - g, i - g, g, 0, Math.PI / 2, !1), n === Rt && (t.lineTo((e + r) / 2, i), t.lineTo(e / 2, i + o), t.lineTo((e - r) / 2, i)), t.lineTo(l, i), t.arc(l, i - l, l, Math.PI / 2, Math.PI, !1), n === Pt && (t.lineTo(0, (i + o) / 2), t.lineTo(-1 * r, i / 2), t.lineTo(0, (i - o) / 2)), t.lineTo(0, a), t.arc(a, a, a, Math.PI, Math.PI * 3 / 2, !1), t.closePath(), t.fillStrokeShape(this);
+  }
+  getSelfRect() {
+    let t = 0, e = 0, i = this.pointerWidth(), n = this.pointerHeight(), r = this.pointerDirection(), o = this.width(), s = this.height();
+    return r === Ct ? (e -= n, s += n) : r === Rt ? s += n : r === Pt ? (t -= i * 1.5, o += i) : r === kt && (o += i * 1.5), {
+      x: t,
+      y: e,
+      width: o,
+      height: s
+    };
+  }
+}
+at.prototype.className = "Tag";
+V(at);
+u.addGetterSetter(at, "pointerDirection", ue);
+u.addGetterSetter(at, "pointerWidth", 0, T());
+u.addGetterSetter(at, "pointerHeight", 0, T());
+u.addGetterSetter(at, "cornerRadius", 0, yt(4));
+class pt extends $ {
+  _sceneFunc(t) {
+    const e = this.cornerRadius(), i = this.width(), n = this.height();
+    t.beginPath(), e ? O.drawRoundedRectPath(t, i, n, e) : t.rect(0, 0, i, n), t.closePath(), t.fillStrokeShape(this);
+  }
+}
+pt.prototype.className = "Rect";
+V(pt);
+u.addGetterSetter(pt, "cornerRadius", 0, yt(4));
+class st extends $ {
+  _sceneFunc(t) {
+    const e = this._getPoints(), i = this.radius(), n = this.sides(), r = this.cornerRadius();
+    if (t.beginPath(), r)
+      O.drawRoundedPolygonPath(t, e, n, i, r);
+    else {
+      t.moveTo(e[0].x, e[0].y);
+      for (let o = 1; o < e.length; o++)
+        t.lineTo(e[o].x, e[o].y);
+    }
+    t.closePath(), t.fillStrokeShape(this);
+  }
+  _getPoints() {
+    const t = this.attrs.sides, e = this.attrs.radius || 0, i = [];
+    for (let n = 0; n < t; n++)
+      i.push({
+        x: e * Math.sin(n * 2 * Math.PI / t),
+        y: -1 * e * Math.cos(n * 2 * Math.PI / t)
+      });
+    return i;
+  }
+  getSelfRect() {
+    const t = this._getPoints();
+    let e = t[0].x, i = t[0].x, n = t[0].y, r = t[0].y;
+    return t.forEach((o) => {
+      e = Math.min(e, o.x), i = Math.max(i, o.x), n = Math.min(n, o.y), r = Math.max(r, o.y);
+    }), {
+      x: e,
+      y: n,
+      width: i - e,
+      height: r - n
+    };
+  }
+  getWidth() {
+    return this.radius() * 2;
+  }
+  getHeight() {
+    return this.radius() * 2;
+  }
+  setWidth(t) {
+    this.radius(t / 2);
+  }
+  setHeight(t) {
+    this.radius(t / 2);
+  }
+}
+st.prototype.className = "RegularPolygon";
+st.prototype._centroid = !0;
+st.prototype._attrsAffectingSize = ["radius"];
+V(st);
+u.addGetterSetter(st, "radius", 0, T());
+u.addGetterSetter(st, "sides", 0, T());
+u.addGetterSetter(st, "cornerRadius", 0, yt(4));
+const zt = Math.PI * 2;
+class ht extends $ {
+  _sceneFunc(t) {
+    t.beginPath(), t.arc(0, 0, this.innerRadius(), 0, zt, !1), t.moveTo(this.outerRadius(), 0), t.arc(0, 0, this.outerRadius(), zt, 0, !0), t.closePath(), t.fillStrokeShape(this);
+  }
+  getWidth() {
+    return this.outerRadius() * 2;
+  }
+  getHeight() {
+    return this.outerRadius() * 2;
+  }
+  setWidth(t) {
+    this.outerRadius(t / 2);
+  }
+  setHeight(t) {
+    this.outerRadius(t / 2);
+  }
+}
+ht.prototype.className = "Ring";
+ht.prototype._centroid = !0;
+ht.prototype._attrsAffectingSize = ["innerRadius", "outerRadius"];
+V(ht);
+u.addGetterSetter(ht, "innerRadius", 0, T());
+u.addGetterSetter(ht, "outerRadius", 0, T());
+class Z extends $ {
+  constructor(t) {
+    super(t), this._updated = !0, this.anim = new oe(() => {
+      const e = this._updated;
+      return this._updated = !1, e;
+    }), this.on("animationChange.konva", function() {
+      this.frameIndex(0);
+    }), this.on("frameIndexChange.konva", function() {
+      this._updated = !0;
+    }), this.on("frameRateChange.konva", function() {
+      this.anim.isRunning() && (clearInterval(this.interval), this._setInterval());
+    });
+  }
+  _sceneFunc(t) {
+    const e = this.animation(), i = this.frameIndex(), n = i * 4, r = this.animations()[e], o = this.frameOffsets(), s = r[n + 0], a = r[n + 1], d = r[n + 2], l = r[n + 3], g = this.image();
+    if ((this.hasFill() || this.hasStroke()) && (t.beginPath(), t.rect(0, 0, d, l), t.closePath(), t.fillStrokeShape(this)), g)
+      if (o) {
+        const c = o[e], p = i * 2;
+        t.drawImage(g, s, a, d, l, c[p + 0], c[p + 1], d, l);
+      } else
+        t.drawImage(g, s, a, d, l, 0, 0, d, l);
+  }
+  _hitFunc(t) {
+    const e = this.animation(), i = this.frameIndex(), n = i * 4, r = this.animations()[e], o = this.frameOffsets(), s = r[n + 2], a = r[n + 3];
+    if (t.beginPath(), o) {
+      const d = o[e], l = i * 2;
+      t.rect(d[l + 0], d[l + 1], s, a);
+    } else
+      t.rect(0, 0, s, a);
+    t.closePath(), t.fillShape(this);
+  }
+  _useBufferCanvas() {
+    return super._useBufferCanvas(!0);
+  }
+  _setInterval() {
+    const t = this;
+    this.interval = setInterval(function() {
+      t._updateIndex();
+    }, 1e3 / this.frameRate());
+  }
+  start() {
+    if (this.isRunning())
+      return;
+    const t = this.getLayer();
+    this.anim.setLayers(t), this._setInterval(), this.anim.start();
+  }
+  stop() {
+    this.anim.stop(), clearInterval(this.interval);
+  }
+  isRunning() {
+    return this.anim.isRunning();
+  }
+  _updateIndex() {
+    const t = this.frameIndex(), e = this.animation(), i = this.animations(), n = i[e], r = n.length / 4;
+    t < r - 1 ? this.frameIndex(t + 1) : this.frameIndex(0);
+  }
+}
+Z.prototype.className = "Sprite";
+V(Z);
+u.addGetterSetter(Z, "animation");
+u.addGetterSetter(Z, "animations");
+u.addGetterSetter(Z, "frameOffsets");
+u.addGetterSetter(Z, "image");
+u.addGetterSetter(Z, "frameIndex", 0, T());
+u.addGetterSetter(Z, "frameRate", 17, T());
+u.backCompat(Z, {
+  index: "frameIndex",
+  getIndex: "getFrameIndex",
+  setIndex: "setFrameIndex"
+});
+class rt extends $ {
+  _sceneFunc(t) {
+    const e = this.innerRadius(), i = this.outerRadius(), n = this.numPoints();
+    t.beginPath(), t.moveTo(0, 0 - i);
+    for (let r = 1; r < n * 2; r++) {
+      const o = r % 2 === 0 ? i : e, s = o * Math.sin(r * Math.PI / n), a = -1 * o * Math.cos(r * Math.PI / n);
+      t.lineTo(s, a);
+    }
+    t.closePath(), t.fillStrokeShape(this);
+  }
+  getWidth() {
+    return this.outerRadius() * 2;
+  }
+  getHeight() {
+    return this.outerRadius() * 2;
+  }
+  setWidth(t) {
+    this.outerRadius(t / 2);
+  }
+  setHeight(t) {
+    this.outerRadius(t / 2);
+  }
+}
+rt.prototype.className = "Star";
+rt.prototype._centroid = !0;
+rt.prototype._attrsAffectingSize = ["innerRadius", "outerRadius"];
+V(rt);
+u.addGetterSetter(rt, "numPoints", 5, T());
+u.addGetterSetter(rt, "innerRadius", 0, T());
+u.addGetterSetter(rt, "outerRadius", 0, T());
+function it(h) {
+  return [...h].reduce((t, e, i, n) => {
+    if (/\p{Emoji}/u.test(e)) {
+      const r = n[i + 1];
+      r && /\p{Emoji_Modifier}|\u200D/u.test(r) ? (t.push(e + r), n[i + 1] = "") : t.push(e);
+    } else /\p{Regional_Indicator}{2}/u.test(e + (n[i + 1] || "")) ? t.push(e + n[i + 1]) : i > 0 && /\p{Mn}|\p{Me}|\p{Mc}/u.test(e) ? t[t.length - 1] += e : e && t.push(e);
+    return t;
+  }, []);
+}
+const lt = "auto", me = "center", $t = "inherit", ft = "justify", Se = "Change.konva", Qt = "2d", Wt = "-", Kt = "left", _e = "text", be = "Text", ye = "top", xe = "bottom", Dt = "middle", Zt = "normal", Me = "px ", mt = " ", ve = "right", Ht = "rtl", Ae = "word", we = "char", Xt = "none", xt = "…", Jt = [
+  "direction",
+  "fontFamily",
+  "fontSize",
+  "fontStyle",
+  "fontVariant",
+  "padding",
+  "align",
+  "verticalAlign",
+  "lineHeight",
+  "text",
+  "width",
+  "height",
+  "wrap",
+  "ellipsis",
+  "letterSpacing"
+], Te = Jt.length;
+let gt = null;
+function Ce() {
+  if (gt !== null)
+    return gt;
+  gt = !1;
+  try {
+    const h = document.createElement("canvas");
+    h.width = 10, h.height = 10;
+    const t = h.getContext(Qt);
+    if (t) {
+      t.globalAlpha = 0, t.shadowColor = "black", t.shadowBlur = 5, t.shadowOffsetX = 5, t.shadowOffsetY = 5, t.fillStyle = "black", t.font = "10px Arial", t.fillText("X", 0, 10);
+      const e = t.getImageData(0, 0, 10, 10).data;
+      for (let i = 3; i < e.length; i += 4)
+        if (e[i] > 0) {
+          gt = !0;
+          break;
+        }
+    }
+  } catch {
+  }
+  return gt;
+}
+function ke(h) {
+  return h.split(",").map((t) => {
+    t = t.trim();
+    const e = t.indexOf(" ") >= 0, i = t.indexOf('"') >= 0 || t.indexOf("'") >= 0;
+    return e && !i && (t = `"${t}"`), t;
+  }).join(", ");
+}
+let St;
+function Mt() {
+  return St || (St = O.createCanvasElement().getContext(Qt), St);
+}
+function Re(h) {
+  h.fillText(this._partialText, this._partialTextX, this._partialTextY);
+}
+function Pe(h) {
+  h.setAttr("miterLimit", 2), h.strokeText(this._partialText, this._partialTextX, this._partialTextY);
+}
+function Le(h) {
+  return h = h || {}, !h.fillLinearGradientColorStops && !h.fillRadialGradientColorStops && !h.fillPatternImage && (h.fill = h.fill || "black"), h;
+}
+class X extends $ {
+  constructor(t) {
+    super(Le(t)), this._partialTextX = 0, this._partialTextY = 0;
+    for (let e = 0; e < Te; e++)
+      this.on(Jt[e] + Se, this._setTextData);
+    this._setTextData();
+  }
+  _sceneFunc(t) {
+    var e, i;
+    const n = this.textArr, r = n.length;
+    if (!this.text())
+      return;
+    let o = this.padding(), s = this.fontSize(), a = this.lineHeight() * s, d = this.verticalAlign(), l = this.direction(), g = 0, c = this.align(), p = this.getWidth(), f = this.letterSpacing(), S = this.charRenderFunc(), _ = this.fill(), b = this.textDecoration(), m = this.underlineOffset(), x = b.indexOf("underline") !== -1, y = b.indexOf("line-through") !== -1, v;
+    l = l === $t ? t.direction : l;
+    let M = a / 2, C = Dt;
+    if (!j.legacyTextRendering) {
+      const A = this.measureSize("M");
+      C = "alphabetic";
+      const k = (e = A.fontBoundingBoxAscent) !== null && e !== void 0 ? e : A.actualBoundingBoxAscent, G = (i = A.fontBoundingBoxDescent) !== null && i !== void 0 ? i : A.actualBoundingBoxDescent;
+      M = (k - G) / 2 + a / 2;
+    }
+    for (l === Ht && t.setAttr("direction", l), t.setAttr("font", this._getContextFont()), t.setAttr("textBaseline", C), t.setAttr("textAlign", Kt), d === Dt ? g = (this.getHeight() - r * a - o * 2) / 2 : d === xe && (g = this.getHeight() - r * a - o * 2), t.translate(o, g + o), v = 0; v < r; v++) {
+      let A = 0, k = 0;
+      const G = n[v], I = G.text, P = G.width, F = G.lastInParagraph;
+      if (t.save(), c === ve ? A += p - P - o * 2 : c === me && (A += (p - P - o * 2) / 2), x) {
+        t.save(), t.beginPath();
+        const L = m ?? (j.legacyTextRendering ? Math.round(s / 2) : Math.round(s / 4)), w = A, D = M + k + L;
+        t.moveTo(w, D);
+        const R = c === ft && !F ? p - o * 2 : P;
+        t.lineTo(w + Math.round(R), D), t.lineWidth = s / 15;
+        const W = this._getLinearGradient();
+        t.strokeStyle = W || _, t.stroke(), t.restore();
+      }
+      const E = A;
+      if (l !== Ht && (f !== 0 || c === ft || S)) {
+        const L = I.split(" ").length - 1, w = it(I);
+        for (let D = 0; D < w.length; D++) {
+          const R = w[D];
+          if (R === " " && !F && c === ft && (A += (p - o * 2 - P) / L), this._partialTextX = A, this._partialTextY = M + k, this._partialText = R, S) {
+            t.save();
+            const U = n.slice(0, v).reduce((Y, Q) => Y + it(Q.text).length, 0), z = D + U;
+            S({
+              char: R,
+              index: z,
+              x: A,
+              y: M + k,
+              lineIndex: v,
+              column: D,
+              isLastInLine: F,
+              width: this.measureSize(R).width,
+              context: t
+            });
+          }
+          t.fillStrokeShape(this), S && t.restore(), A += this.measureSize(R).width + f;
+        }
+      } else
+        f !== 0 && t.setAttr("letterSpacing", `${f}px`), this._partialTextX = A, this._partialTextY = M + k, this._partialText = I, t.fillStrokeShape(this);
+      if (y) {
+        t.save(), t.beginPath();
+        const L = j.legacyTextRendering ? 0 : -Math.round(s / 4), w = E;
+        t.moveTo(w, M + k + L);
+        const D = c === ft && !F ? p - o * 2 : P;
+        t.lineTo(w + Math.round(D), M + k + L), t.lineWidth = s / 15;
+        const R = this._getLinearGradient();
+        t.strokeStyle = R || _, t.stroke(), t.restore();
+      }
+      t.restore(), r > 1 && (M += a);
+    }
+  }
+  _hitFunc(t) {
+    const e = this.getWidth(), i = this.getHeight();
+    t.beginPath(), t.rect(0, 0, e, i), t.closePath(), t.fillStrokeShape(this);
+  }
+  setText(t) {
+    const e = O._isString(t) ? t : t == null ? "" : t + "";
+    return this._setAttr(_e, e), this;
+  }
+  getWidth() {
+    return this.attrs.width === lt || this.attrs.width === void 0 ? this.getTextWidth() + this.padding() * 2 : this.attrs.width;
+  }
+  getHeight() {
+    return this.attrs.height === lt || this.attrs.height === void 0 ? this.fontSize() * this.textArr.length * this.lineHeight() + this.padding() * 2 : this.attrs.height;
+  }
+  getTextWidth() {
+    return this.textWidth;
+  }
+  getTextHeight() {
+    return O.warn("text.getTextHeight() method is deprecated. Use text.height() - for full height and text.fontSize() - for one line height."), this.textHeight;
+  }
+  measureSize(t) {
+    var e, i, n, r, o, s, a, d, l, g, c;
+    let p = Mt(), f = this.fontSize(), S;
+    p.save(), p.font = this._getContextFont(), S = p.measureText(t), p.restore();
+    const _ = f / 100;
+    return {
+      actualBoundingBoxAscent: (e = S.actualBoundingBoxAscent) !== null && e !== void 0 ? e : 71.58203125 * _,
+      actualBoundingBoxDescent: (i = S.actualBoundingBoxDescent) !== null && i !== void 0 ? i : 0,
+      actualBoundingBoxLeft: (n = S.actualBoundingBoxLeft) !== null && n !== void 0 ? n : -7.421875 * _,
+      actualBoundingBoxRight: (r = S.actualBoundingBoxRight) !== null && r !== void 0 ? r : 75.732421875 * _,
+      alphabeticBaseline: (o = S.alphabeticBaseline) !== null && o !== void 0 ? o : 0,
+      emHeightAscent: (s = S.emHeightAscent) !== null && s !== void 0 ? s : 100 * _,
+      emHeightDescent: (a = S.emHeightDescent) !== null && a !== void 0 ? a : -20 * _,
+      fontBoundingBoxAscent: (d = S.fontBoundingBoxAscent) !== null && d !== void 0 ? d : 91 * _,
+      fontBoundingBoxDescent: (l = S.fontBoundingBoxDescent) !== null && l !== void 0 ? l : 21 * _,
+      hangingBaseline: (g = S.hangingBaseline) !== null && g !== void 0 ? g : 72.80000305175781 * _,
+      ideographicBaseline: (c = S.ideographicBaseline) !== null && c !== void 0 ? c : -21 * _,
+      width: S.width,
+      height: f
+    };
+  }
+  _getContextFont() {
+    return this.fontStyle() + mt + this.fontVariant() + mt + (this.fontSize() + Me) + ke(this.fontFamily());
+  }
+  _addTextLine(t) {
+    this.align() === ft && (t = t.trim());
+    const i = this._getTextWidth(t);
+    return this.textArr.push({
+      text: t,
+      width: i,
+      lastInParagraph: !1
+    });
+  }
+  _getTextWidth(t) {
+    const e = this.letterSpacing(), i = t.length;
+    return Mt().measureText(t).width + e * i;
+  }
+  _setTextData() {
+    let t = this.text().split(`
+`), e = +this.fontSize(), i = 0, n = this.lineHeight() * e, r = this.attrs.width, o = this.attrs.height, s = r !== lt && r !== void 0, a = o !== lt && o !== void 0, d = this.padding(), l = r - d * 2, g = o - d * 2, c = 0, p = this.wrap(), f = p !== Xt, S = p !== we && f, _ = this.ellipsis();
+    this.textArr = [], Mt().font = this._getContextFont();
+    const b = _ ? this._getTextWidth(xt) : 0;
+    for (let m = 0, x = t.length; m < x; ++m) {
+      let y = t[m], v = this._getTextWidth(y);
+      if (s && v > l)
+        for (; y.length > 0; ) {
+          let M = 0, C = it(y).length, A = "", k = 0;
+          for (; M < C; ) {
+            const G = M + C >>> 1, I = it(y), P = I.slice(0, G + 1).join(""), F = this._getTextWidth(P);
+            (_ && a && c + n > g ? F + b : F) <= l ? (M = G + 1, A = P, k = F) : C = G;
+          }
+          if (A) {
+            if (S) {
+              const P = it(y), F = it(A), E = P[F.length], L = E === mt || E === Wt;
+              let w;
+              if (L && k <= l)
+                w = F.length;
+              else {
+                const D = F.lastIndexOf(mt), R = F.lastIndexOf(Wt);
+                w = Math.max(D, R) + 1;
+              }
+              w > 0 && (M = w, A = P.slice(0, M).join(""), k = this._getTextWidth(A));
+            }
+            if (A = A.trimRight(), this._addTextLine(A), i = Math.max(i, k), c += n, this._shouldHandleEllipsis(c)) {
+              this._tryToAddEllipsisToLastLine();
+              break;
+            }
+            if (y = it(y).slice(M).join("").trimLeft(), y.length > 0 && (v = this._getTextWidth(y), v <= l)) {
+              this._addTextLine(y), c += n, i = Math.max(i, v);
+              break;
+            }
+          } else
+            break;
+        }
+      else
+        this._addTextLine(y), c += n, i = Math.max(i, v), this._shouldHandleEllipsis(c) && m < x - 1 && this._tryToAddEllipsisToLastLine();
+      if (this.textArr[this.textArr.length - 1] && (this.textArr[this.textArr.length - 1].lastInParagraph = !0), a && c + n > g)
+        break;
+    }
+    this.textHeight = e, this.textWidth = i;
+  }
+  _shouldHandleEllipsis(t) {
+    const e = +this.fontSize(), i = this.lineHeight() * e, n = this.attrs.height, r = n !== lt && n !== void 0, o = this.padding(), s = n - o * 2;
+    return !(this.wrap() !== Xt) || r && t + i > s;
+  }
+  _tryToAddEllipsisToLastLine() {
+    const t = this.attrs.width, e = t !== lt && t !== void 0, i = this.padding(), n = t - i * 2, r = this.ellipsis(), o = this.textArr[this.textArr.length - 1];
+    !o || !r || (e && (this._getTextWidth(o.text + xt) < n || (o.text = o.text.slice(0, o.text.length - 3))), this.textArr.splice(this.textArr.length - 1, 1), this._addTextLine(o.text + xt));
+  }
+  getStrokeScaleEnabled() {
+    return !0;
+  }
+  _useBufferCanvas() {
+    const t = this.textDecoration().indexOf("underline") !== -1 || this.textDecoration().indexOf("line-through") !== -1, e = this.hasShadow();
+    return t && e || e && this.getAbsoluteOpacity() !== 1 && Ce() ? !0 : super._useBufferCanvas();
+  }
+}
+X.prototype._fillFunc = Re;
+X.prototype._strokeFunc = Pe;
+X.prototype.className = be;
+X.prototype._attrsAffectingSize = [
+  "text",
+  "fontSize",
+  "padding",
+  "wrap",
+  "lineHeight",
+  "letterSpacing"
+];
+V(X);
+u.overWriteSetter(X, "width", Ut());
+u.overWriteSetter(X, "height", Ut());
+u.addGetterSetter(X, "direction", $t);
+u.addGetterSetter(X, "fontFamily", "Arial");
+u.addGetterSetter(X, "fontSize", 12, T());
+u.addGetterSetter(X, "fontStyle", Zt);
+u.addGetterSetter(X, "fontVariant", Zt);
+u.addGetterSetter(X, "padding", 0, T());
+u.addGetterSetter(X, "align", Kt);
+u.addGetterSetter(X, "verticalAlign", ye);
+u.addGetterSetter(X, "lineHeight", 1, T());
+u.addGetterSetter(X, "wrap", Ae);
+u.addGetterSetter(X, "ellipsis", !1, Gt());
+u.addGetterSetter(X, "letterSpacing", 0, T());
+u.addGetterSetter(X, "text", "", ae());
+u.addGetterSetter(X, "textDecoration", "");
+u.addGetterSetter(X, "underlineOffset", void 0, T());
+u.addGetterSetter(X, "charRenderFunc", void 0);
+const Ge = "", te = "normal";
+function ee(h) {
+  h.fillText(this.partialText, 0, 0);
+}
+function ie(h) {
+  h.strokeText(this.partialText, 0, 0);
+}
+class q extends $ {
+  constructor(t) {
+    super(t), this.dummyCanvas = O.createCanvasElement(), this.dataArray = [], this._readDataAttribute(), this.on("dataChange.konva", function() {
+      this._readDataAttribute(), this._setTextData();
+    }), this.on("textChange.konva alignChange.konva letterSpacingChange.konva kerningFuncChange.konva fontSizeChange.konva fontFamilyChange.konva directionChange.konva", this._setTextData), this._setTextData();
+  }
+  _getTextPathLength() {
+    return H.getPathLength(this.dataArray);
+  }
+  _getPointAtLength(t) {
+    if (!this.attrs.data)
+      return null;
+    const e = this.pathLength;
+    return t > e ? null : H.getPointAtLengthOfDataArray(t, this.dataArray);
+  }
+  _readDataAttribute() {
+    this.dataArray = H.parsePathData(this.attrs.data), this.pathLength = this._getTextPathLength();
+  }
+  _sceneFunc(t) {
+    t.setAttr("font", this._getContextFont()), t.setAttr("textBaseline", this.textBaseline()), t.setAttr("textAlign", "left"), t.save();
+    const e = this.textDecoration(), i = this.fill(), n = this.fontSize(), r = this.glyphInfo, o = e.indexOf("underline") !== -1, s = e.indexOf("line-through") !== -1;
+    o && t.beginPath();
+    for (let a = 0; a < r.length; a++) {
+      t.save();
+      const d = r[a].p0;
+      t.translate(d.x, d.y), t.rotate(r[a].rotation), this.partialText = r[a].text, t.fillStrokeShape(this), o && (a === 0 && t.moveTo(0, n / 2 + 1), t.lineTo(r[a].width, n / 2 + 1)), t.restore();
+    }
+    if (o && (t.strokeStyle = i, t.lineWidth = n / 20, t.stroke()), s) {
+      t.beginPath();
+      for (let a = 0; a < r.length; a++) {
+        t.save();
+        const d = r[a].p0;
+        t.translate(d.x, d.y), t.rotate(r[a].rotation), a === 0 && t.moveTo(0, 0), t.lineTo(r[a].width, 0), t.restore();
+      }
+      t.strokeStyle = i, t.lineWidth = n / 20, t.stroke();
+    }
+    t.restore();
+  }
+  _hitFunc(t) {
+    t.beginPath();
+    const e = this.glyphInfo;
+    if (e.length >= 1) {
+      const i = e[0].p0;
+      t.moveTo(i.x, i.y);
+    }
+    for (let i = 0; i < e.length; i++) {
+      const n = e[i].p1;
+      t.lineTo(n.x, n.y);
+    }
+    t.setAttr("lineWidth", this.fontSize()), t.setAttr("strokeStyle", this.colorKey), t.stroke();
+  }
+  getTextWidth() {
+    return this.textWidth;
+  }
+  getTextHeight() {
+    return O.warn("text.getTextHeight() method is deprecated. Use text.height() - for full height and text.fontSize() - for one line height."), this.textHeight;
+  }
+  setText(t) {
+    return X.prototype.setText.call(this, t);
+  }
+  _getContextFont() {
+    return X.prototype._getContextFont.call(this);
+  }
+  _getTextSize(t) {
+    const i = this.dummyCanvas.getContext("2d");
+    i.save(), i.font = this._getContextFont();
+    const n = i.measureText(t);
+    return i.restore(), {
+      width: n.width,
+      height: parseInt(`${this.fontSize()}`, 10)
+    };
+  }
+  _setTextData() {
+    const t = it(this.text());
+    this.direction() === "rtl" && t.reverse();
+    const e = [];
+    let i = 0;
+    for (let p = 0; p < t.length; p++)
+      e.push({
+        char: t[p],
+        width: this._getTextSize(t[p]).width
+      }), i += e[p].width;
+    const { width: n, height: r } = this._getTextSize(this.attrs.text);
+    if (this.textWidth = i, this.textHeight = r, this.glyphInfo = [], !this.attrs.data)
+      return null;
+    const o = this.letterSpacing(), s = this.align(), a = this.kerningFunc(), d = Math.max(0, i - n), l = Math.max(this.textWidth + ((this.attrs.text || "").length - 1) * o, 0);
+    let g = 0;
+    s === "center" && (g = Math.max(0, this.pathLength / 2 - l / 2)), s === "right" && (g = Math.max(0, this.pathLength - l));
+    let c = g;
+    for (let p = 0; p < e.length; p++) {
+      const f = this._getPointAtLength(c);
+      if (!f)
+        return;
+      const S = e[p].char;
+      let _ = e[p].width + o;
+      if (S === " " && s === "justify") {
+        const C = this.text().split(" ").length - 1;
+        _ += (this.pathLength - l) / C;
+      }
+      const b = c + _, m = this._getPointAtLength(b > this.pathLength && b - this.pathLength <= d ? this.pathLength : b);
+      if (!m)
+        return;
+      const x = H.getLineLength(f.x, f.y, m.x, m.y);
+      let y = 0;
+      if (a)
+        try {
+          y = a(e[p - 1].char, S) * this.fontSize();
+        } catch {
+          y = 0;
+        }
+      f.x += y, m.x += y, this.textWidth += y;
+      const v = H.getPointOnLine(y + x / 2, f.x, f.y, m.x, m.y), M = Math.atan2(m.y - f.y, m.x - f.x);
+      this.glyphInfo.push({
+        transposeX: v.x,
+        transposeY: v.y,
+        text: t[p],
+        rotation: M,
+        p0: f,
+        p1: m,
+        width: x
+      }), c += _;
+    }
+  }
+  getSelfRect() {
+    if (!this.glyphInfo.length)
+      return {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      };
+    const t = [];
+    this.glyphInfo.forEach(function(d) {
+      t.push(d.p0.x), t.push(d.p0.y), t.push(d.p1.x), t.push(d.p1.y);
+    });
+    let e = t[0] || 0, i = t[0] || 0, n = t[1] || 0, r = t[1] || 0, o, s;
+    for (let d = 0; d < t.length / 2; d++)
+      o = t[d * 2], s = t[d * 2 + 1], e = Math.min(e, o), i = Math.max(i, o), n = Math.min(n, s), r = Math.max(r, s);
+    const a = this.fontSize();
+    return {
+      x: e - a / 2,
+      y: n - a / 2,
+      width: i - e + a,
+      height: r - n + a
+    };
+  }
+  destroy() {
+    return O.releaseCanvas(this.dummyCanvas), super.destroy();
+  }
+}
+q.prototype._fillFunc = ee;
+q.prototype._strokeFunc = ie;
+q.prototype._fillFuncHit = ee;
+q.prototype._strokeFuncHit = ie;
+q.prototype.className = "TextPath";
+q.prototype._attrsAffectingSize = ["text", "fontSize", "data"];
+V(q);
+u.addGetterSetter(q, "data");
+u.addGetterSetter(q, "fontFamily", "Arial");
+u.addGetterSetter(q, "fontSize", 12, T());
+u.addGetterSetter(q, "fontStyle", te);
+u.addGetterSetter(q, "align", "left");
+u.addGetterSetter(q, "letterSpacing", 0, T());
+u.addGetterSetter(q, "textBaseline", "middle");
+u.addGetterSetter(q, "fontVariant", te);
+u.addGetterSetter(q, "text", Ge);
+u.addGetterSetter(q, "textDecoration", "");
+u.addGetterSetter(q, "kerningFunc", void 0);
+u.addGetterSetter(q, "direction", "inherit");
+const ne = "tr-konva", Oe = [
+  "resizeEnabledChange",
+  "rotateAnchorOffsetChange",
+  "rotateAnchorAngleChange",
+  "rotateEnabledChange",
+  "enabledAnchorsChange",
+  "anchorSizeChange",
+  "borderEnabledChange",
+  "borderStrokeChange",
+  "borderStrokeWidthChange",
+  "borderDashChange",
+  "anchorStrokeChange",
+  "anchorStrokeWidthChange",
+  "anchorFillChange",
+  "anchorCornerRadiusChange",
+  "ignoreStrokeChange",
+  "anchorStyleFuncChange"
+].map((h) => h + `.${ne}`).join(" "), Yt = "nodesRect", Ee = [
+  "widthChange",
+  "heightChange",
+  "scaleXChange",
+  "scaleYChange",
+  "skewXChange",
+  "skewYChange",
+  "rotationChange",
+  "offsetXChange",
+  "offsetYChange",
+  "transformsEnabledChange",
+  "strokeWidthChange",
+  "draggableChange"
+], Ne = {
+  "top-left": -45,
+  "top-center": 0,
+  "top-right": 45,
+  "middle-right": -90,
+  "middle-left": 90,
+  "bottom-left": -135,
+  "bottom-center": 180,
+  "bottom-right": 135
+}, Ie = "ontouchstart" in j._global;
+function Fe(h, t, e) {
+  if (h === "rotater")
+    return e;
+  t += O.degToRad(Ne[h] || 0);
+  const i = (O.radToDeg(t) % 360 + 360) % 360;
+  return O._inRange(i, 315 + 22.5, 360) || O._inRange(i, 0, 22.5) ? "ns-resize" : O._inRange(i, 45 - 22.5, 45 + 22.5) ? "nesw-resize" : O._inRange(i, 90 - 22.5, 90 + 22.5) ? "ew-resize" : O._inRange(i, 135 - 22.5, 135 + 22.5) ? "nwse-resize" : O._inRange(i, 180 - 22.5, 180 + 22.5) ? "ns-resize" : O._inRange(i, 225 - 22.5, 225 + 22.5) ? "nesw-resize" : O._inRange(i, 270 - 22.5, 270 + 22.5) ? "ew-resize" : O._inRange(i, 315 - 22.5, 315 + 22.5) ? "nwse-resize" : (O.error("Transformer has unknown angle for cursor detection: " + i), "pointer");
+}
+const bt = [
+  "top-left",
+  "top-center",
+  "top-right",
+  "middle-right",
+  "middle-left",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right"
+];
+function Be(h) {
+  return {
+    x: h.x + h.width / 2 * Math.cos(h.rotation) + h.height / 2 * Math.sin(-h.rotation),
+    y: h.y + h.height / 2 * Math.cos(h.rotation) + h.width / 2 * Math.sin(h.rotation)
+  };
+}
+function se(h, t, e) {
+  const i = e.x + (h.x - e.x) * Math.cos(t) - (h.y - e.y) * Math.sin(t), n = e.y + (h.x - e.x) * Math.sin(t) + (h.y - e.y) * Math.cos(t);
+  return {
+    ...h,
+    rotation: h.rotation + t,
+    x: i,
+    y: n
+  };
+}
+function ze(h, t) {
+  const e = Be(h);
+  return se(h, t, e);
+}
+function We(h, t, e) {
+  let i = t;
+  for (let n = 0; n < h.length; n++) {
+    const r = j.getAngle(h[n]), o = Math.abs(r - t) % (Math.PI * 2);
+    Math.min(o, Math.PI * 2 - o) < e && (i = r);
+  }
+  return i;
+}
+let Lt = 0;
+class N extends At {
+  constructor(t) {
+    super(t), this._movingAnchorName = null, this._transforming = !1, this._elementsCreated = !1, this._createElements(), this._handleMouseMove = this._handleMouseMove.bind(this), this._handleMouseUp = this._handleMouseUp.bind(this), this.update = this.update.bind(this), this.on(Oe, this.update), this.getNode() && this.update();
+  }
+  attachTo(t) {
+    return this.setNode(t), this;
+  }
+  setNode(t) {
+    return O.warn("tr.setNode(shape), tr.node(shape) and tr.attachTo(shape) methods are deprecated. Please use tr.nodes(nodesArray) instead."), this.setNodes([t]);
+  }
+  getNode() {
+    return this._nodes && this._nodes[0];
+  }
+  _getEventNamespace() {
+    return ne + this._id;
+  }
+  setNodes(t = []) {
+    this._nodes && this._nodes.length && this.detach();
+    const e = t.filter((n) => n.isAncestorOf(this) ? (O.error("Konva.Transformer cannot be an a child of the node you are trying to attach"), !1) : !0);
+    return this._nodes = t = e, t.length === 1 && this.useSingleNodeRotation() ? this.rotation(t[0].getAbsoluteRotation()) : this.rotation(0), this._nodes.forEach((n) => {
+      const r = () => {
+        this.nodes().length === 1 && this.useSingleNodeRotation() && this.rotation(this.nodes()[0].getAbsoluteRotation()), this._resetTransformCache(), !this._transforming && !this.isDragging() && this.update();
+      };
+      if (n._attrsAffectingSize.length) {
+        const o = n._attrsAffectingSize.map((s) => s + "Change." + this._getEventNamespace()).join(" ");
+        n.on(o, r);
+      }
+      n.on(Ee.map((o) => o + `.${this._getEventNamespace()}`).join(" "), r), n.on(`absoluteTransformChange.${this._getEventNamespace()}`, r), this._proxyDrag(n);
+    }), this._resetTransformCache(), !!this.findOne(".top-left") && this.update(), this;
+  }
+  _proxyDrag(t) {
+    let e;
+    t.on(`dragstart.${this._getEventNamespace()}`, (i) => {
+      e = t.getAbsolutePosition(), !this.isDragging() && t !== this.findOne(".back") && this.startDrag(i, !1);
+    }), t.on(`dragmove.${this._getEventNamespace()}`, (i) => {
+      if (!e)
+        return;
+      const n = t.getAbsolutePosition(), r = n.x - e.x, o = n.y - e.y;
+      this.nodes().forEach((s) => {
+        if (s === t || s.isDragging())
+          return;
+        const a = s.getAbsolutePosition();
+        s.setAbsolutePosition({
+          x: a.x + r,
+          y: a.y + o
+        }), s.startDrag(i);
+      }), e = null;
+    });
+  }
+  getNodes() {
+    return this._nodes || [];
+  }
+  getActiveAnchor() {
+    return this._movingAnchorName;
+  }
+  detach() {
+    this._nodes && this._nodes.forEach((t) => {
+      t.off("." + this._getEventNamespace());
+    }), this._nodes = [], this._resetTransformCache();
+  }
+  _resetTransformCache() {
+    this._clearCache(Yt), this._clearCache("transform"), this._clearSelfAndDescendantCache("absoluteTransform");
+  }
+  _getNodeRect() {
+    return this._getCache(Yt, this.__getNodeRect);
+  }
+  __getNodeShape(t, e = this.rotation(), i) {
+    const n = t.getClientRect({
+      skipTransform: !0,
+      skipShadow: !0,
+      skipStroke: this.ignoreStroke()
+    }), r = t.getAbsoluteScale(i), o = t.getAbsolutePosition(i), s = n.x * r.x - t.offsetX() * r.x, a = n.y * r.y - t.offsetY() * r.y, d = (j.getAngle(t.getAbsoluteRotation()) + Math.PI * 2) % (Math.PI * 2), l = {
+      x: o.x + s * Math.cos(d) + a * Math.sin(-d),
+      y: o.y + a * Math.cos(d) + s * Math.sin(d),
+      width: n.width * r.x,
+      height: n.height * r.y,
+      rotation: d
+    };
+    return se(l, -j.getAngle(e), {
+      x: 0,
+      y: 0
+    });
+  }
+  __getNodeRect() {
+    if (!this.getNode())
+      return {
+        x: -1e8,
+        y: -1e8,
+        width: 0,
+        height: 0,
+        rotation: 0
+      };
+    const e = [];
+    this.nodes().map((d) => {
+      const l = d.getClientRect({
+        skipTransform: !0,
+        skipShadow: !0,
+        skipStroke: this.ignoreStroke()
+      }), g = [
+        { x: l.x, y: l.y },
+        { x: l.x + l.width, y: l.y },
+        { x: l.x + l.width, y: l.y + l.height },
+        { x: l.x, y: l.y + l.height }
+      ], c = d.getAbsoluteTransform();
+      g.forEach(function(p) {
+        const f = c.point(p);
+        e.push(f);
+      });
+    });
+    const i = new ct();
+    i.rotate(-j.getAngle(this.rotation()));
+    let n = 1 / 0, r = 1 / 0, o = -1 / 0, s = -1 / 0;
+    e.forEach(function(d) {
+      const l = i.point(d);
+      n === void 0 && (n = o = l.x, r = s = l.y), n = Math.min(n, l.x), r = Math.min(r, l.y), o = Math.max(o, l.x), s = Math.max(s, l.y);
+    }), i.invert();
+    const a = i.point({ x: n, y: r });
+    return {
+      x: a.x,
+      y: a.y,
+      width: o - n,
+      height: s - r,
+      rotation: j.getAngle(this.rotation())
+    };
+  }
+  getX() {
+    return this._getNodeRect().x;
+  }
+  getY() {
+    return this._getNodeRect().y;
+  }
+  getWidth() {
+    return this._getNodeRect().width;
+  }
+  getHeight() {
+    return this._getNodeRect().height;
+  }
+  _createElements() {
+    this._createBack(), bt.forEach((t) => {
+      this._createAnchor(t);
+    }), this._createAnchor("rotater"), this._elementsCreated = !0;
+  }
+  _createAnchor(t) {
+    const e = new pt({
+      stroke: "rgb(0, 161, 255)",
+      fill: "white",
+      strokeWidth: 1,
+      name: t + " _anchor",
+      dragDistance: 0,
+      draggable: !0,
+      hitStrokeWidth: Ie ? 10 : "auto"
+    }), i = this;
+    e.on("mousedown touchstart", function(n) {
+      i._handleMouseDown(n);
+    }), e.on("dragstart", (n) => {
+      e.stopDrag(), n.cancelBubble = !0;
+    }), e.on("dragend", (n) => {
+      n.cancelBubble = !0;
+    }), e.on("mouseenter", () => {
+      const n = j.getAngle(this.rotation()), r = this.rotateAnchorCursor(), o = Fe(t, n, r);
+      e.getStage().content && (e.getStage().content.style.cursor = o), this._cursorChange = !0;
+    }), e.on("mouseout", () => {
+      e.getStage().content && (e.getStage().content.style.cursor = ""), this._cursorChange = !1;
+    }), this.add(e);
+  }
+  _createBack() {
+    const t = new $({
+      name: "back",
+      width: 0,
+      height: 0,
+      sceneFunc(e, i) {
+        const n = i.getParent(), r = n.padding(), o = i.width(), s = i.height();
+        if (e.beginPath(), e.rect(-r, -r, o + r * 2, s + r * 2), n.rotateEnabled() && n.rotateLineVisible()) {
+          const a = n.rotateAnchorAngle(), d = n.rotateAnchorOffset(), l = O.degToRad(a), g = Math.sin(l), c = -Math.cos(l), p = o / 2, f = s / 2;
+          let S = 1 / 0;
+          c < 0 ? S = Math.min(S, -f / c) : c > 0 && (S = Math.min(S, (s - f) / c)), g < 0 ? S = Math.min(S, -p / g) : g > 0 && (S = Math.min(S, (o - p) / g));
+          const _ = p + g * S, b = f + c * S, m = O._sign(s), x = _ + g * d * m, y = b + c * d * m;
+          e.moveTo(_, b), e.lineTo(x, y);
+        }
+        e.fillStrokeShape(i);
+      },
+      hitFunc: (e, i) => {
+        if (!this.shouldOverdrawWholeArea())
+          return;
+        const n = this.padding();
+        e.beginPath(), e.rect(-n, -n, i.width() + n * 2, i.height() + n * 2), e.fillStrokeShape(i);
+      }
+    });
+    this.add(t), this._proxyDrag(t), t.on("dragstart", (e) => {
+      e.cancelBubble = !0;
+    }), t.on("dragmove", (e) => {
+      e.cancelBubble = !0;
+    }), t.on("dragend", (e) => {
+      e.cancelBubble = !0;
+    }), this.on("dragmove", (e) => {
+      this.update();
+    });
+  }
+  _handleMouseDown(t) {
+    if (this._transforming)
+      return;
+    this._movingAnchorName = t.target.name().split(" ")[0];
+    const e = this._getNodeRect(), i = e.width, n = e.height, r = Math.sqrt(Math.pow(i, 2) + Math.pow(n, 2));
+    this.sin = Math.abs(n / r), this.cos = Math.abs(i / r), typeof window < "u" && (window.addEventListener("mousemove", this._handleMouseMove), window.addEventListener("touchmove", this._handleMouseMove), window.addEventListener("mouseup", this._handleMouseUp, !0), window.addEventListener("touchend", this._handleMouseUp, !0)), this._transforming = !0;
+    const o = t.target.getAbsolutePosition(), s = t.target.getStage().getPointerPosition();
+    this._anchorDragOffset = {
+      x: s.x - o.x,
+      y: s.y - o.y
+    }, Lt++, this._fire("transformstart", { evt: t.evt, target: this.getNode() }), this._nodes.forEach((a) => {
+      a._fire("transformstart", { evt: t.evt, target: a });
+    });
+  }
+  _handleMouseMove(t) {
+    let e, i, n;
+    const r = this.findOne("." + this._movingAnchorName), o = r.getStage();
+    o.setPointersPositions(t);
+    const s = o.getPointerPosition();
+    let a = {
+      x: s.x - this._anchorDragOffset.x,
+      y: s.y - this._anchorDragOffset.y
+    };
+    const d = r.getAbsolutePosition();
+    this.anchorDragBoundFunc() && (a = this.anchorDragBoundFunc()(d, a, t)), r.setAbsolutePosition(a);
+    const l = r.getAbsolutePosition();
+    if (d.x === l.x && d.y === l.y)
+      return;
+    if (this._movingAnchorName === "rotater") {
+      const m = this._getNodeRect();
+      e = r.x() - m.width / 2, i = -r.y() + m.height / 2;
+      const x = j.getAngle(this.rotateAnchorAngle());
+      let y = Math.atan2(-i, e) + Math.PI / 2 - x;
+      m.height < 0 && (y -= Math.PI);
+      const M = j.getAngle(this.rotation()) + y, C = j.getAngle(this.rotationSnapTolerance()), k = We(this.rotationSnaps(), M, C) - m.rotation, G = ze(m, k);
+      this._fitNodesInto(G, t);
+      return;
+    }
+    const g = this.shiftBehavior();
+    let c;
+    g === "inverted" ? c = this.keepRatio() && !t.shiftKey : g === "none" ? c = this.keepRatio() : c = this.keepRatio() || t.shiftKey;
+    let p = this.centeredScaling() || t.altKey;
+    if (this._movingAnchorName === "top-left") {
+      if (c) {
+        const m = p ? {
+          x: this.width() / 2,
+          y: this.height() / 2
+        } : {
+          x: this.findOne(".bottom-right").x(),
+          y: this.findOne(".bottom-right").y()
+        };
+        n = Math.sqrt(Math.pow(m.x - r.x(), 2) + Math.pow(m.y - r.y(), 2));
+        const x = this.findOne(".top-left").x() > m.x ? -1 : 1, y = this.findOne(".top-left").y() > m.y ? -1 : 1;
+        e = n * this.cos * x, i = n * this.sin * y, this.findOne(".top-left").x(m.x - e), this.findOne(".top-left").y(m.y - i);
+      }
+    } else if (this._movingAnchorName === "top-center")
+      this.findOne(".top-left").y(r.y());
+    else if (this._movingAnchorName === "top-right") {
+      if (c) {
+        const m = p ? {
+          x: this.width() / 2,
+          y: this.height() / 2
+        } : {
+          x: this.findOne(".bottom-left").x(),
+          y: this.findOne(".bottom-left").y()
+        };
+        n = Math.sqrt(Math.pow(r.x() - m.x, 2) + Math.pow(m.y - r.y(), 2));
+        const x = this.findOne(".top-right").x() < m.x ? -1 : 1, y = this.findOne(".top-right").y() > m.y ? -1 : 1;
+        e = n * this.cos * x, i = n * this.sin * y, this.findOne(".top-right").x(m.x + e), this.findOne(".top-right").y(m.y - i);
+      }
+      var f = r.position();
+      this.findOne(".top-left").y(f.y), this.findOne(".bottom-right").x(f.x);
+    } else if (this._movingAnchorName === "middle-left")
+      this.findOne(".top-left").x(r.x());
+    else if (this._movingAnchorName === "middle-right")
+      this.findOne(".bottom-right").x(r.x());
+    else if (this._movingAnchorName === "bottom-left") {
+      if (c) {
+        const m = p ? {
+          x: this.width() / 2,
+          y: this.height() / 2
+        } : {
+          x: this.findOne(".top-right").x(),
+          y: this.findOne(".top-right").y()
+        };
+        n = Math.sqrt(Math.pow(m.x - r.x(), 2) + Math.pow(r.y() - m.y, 2));
+        const x = m.x < r.x() ? -1 : 1, y = r.y() < m.y ? -1 : 1;
+        e = n * this.cos * x, i = n * this.sin * y, r.x(m.x - e), r.y(m.y + i);
+      }
+      f = r.position(), this.findOne(".top-left").x(f.x), this.findOne(".bottom-right").y(f.y);
+    } else if (this._movingAnchorName === "bottom-center")
+      this.findOne(".bottom-right").y(r.y());
+    else if (this._movingAnchorName === "bottom-right") {
+      if (c) {
+        const m = p ? {
+          x: this.width() / 2,
+          y: this.height() / 2
+        } : {
+          x: this.findOne(".top-left").x(),
+          y: this.findOne(".top-left").y()
+        };
+        n = Math.sqrt(Math.pow(r.x() - m.x, 2) + Math.pow(r.y() - m.y, 2));
+        const x = this.findOne(".bottom-right").x() < m.x ? -1 : 1, y = this.findOne(".bottom-right").y() < m.y ? -1 : 1;
+        e = n * this.cos * x, i = n * this.sin * y, this.findOne(".bottom-right").x(m.x + e), this.findOne(".bottom-right").y(m.y + i);
+      }
+    } else
+      console.error(new Error("Wrong position argument of selection resizer: " + this._movingAnchorName));
+    if (p = this.centeredScaling() || t.altKey, p) {
+      const m = this.findOne(".top-left"), x = this.findOne(".bottom-right"), y = m.x(), v = m.y(), M = this.getWidth() - x.x(), C = this.getHeight() - x.y();
+      x.move({
+        x: -y,
+        y: -v
+      }), m.move({
+        x: M,
+        y: C
+      });
+    }
+    const S = this.findOne(".top-left").getAbsolutePosition();
+    e = S.x, i = S.y;
+    const _ = this.findOne(".bottom-right").x() - this.findOne(".top-left").x(), b = this.findOne(".bottom-right").y() - this.findOne(".top-left").y();
+    this._fitNodesInto({
+      x: e,
+      y: i,
+      width: _,
+      height: b,
+      rotation: j.getAngle(this.rotation())
+    }, t);
+  }
+  _handleMouseUp(t) {
+    this._removeEvents(t);
+  }
+  getAbsoluteTransform() {
+    return this.getTransform();
+  }
+  _removeEvents(t) {
+    var e;
+    if (this._transforming) {
+      this._transforming = !1, typeof window < "u" && (window.removeEventListener("mousemove", this._handleMouseMove), window.removeEventListener("touchmove", this._handleMouseMove), window.removeEventListener("mouseup", this._handleMouseUp, !0), window.removeEventListener("touchend", this._handleMouseUp, !0));
+      const i = this.getNode();
+      Lt--, this._fire("transformend", { evt: t, target: i }), (e = this.getLayer()) === null || e === void 0 || e.batchDraw(), i && this._nodes.forEach((n) => {
+        var r;
+        n._fire("transformend", { evt: t, target: n }), (r = n.getLayer()) === null || r === void 0 || r.batchDraw();
+      }), this._movingAnchorName = null;
+    }
+  }
+  _fitNodesInto(t, e) {
+    const i = this._getNodeRect(), n = 1;
+    if (O._inRange(t.width, -this.padding() * 2 - n, n)) {
+      this.update();
+      return;
+    }
+    if (O._inRange(t.height, -this.padding() * 2 - n, n)) {
+      this.update();
+      return;
+    }
+    const r = new ct();
+    if (r.rotate(j.getAngle(this.rotation())), this._movingAnchorName && t.width < 0 && this._movingAnchorName.indexOf("left") >= 0) {
+      const c = r.point({
+        x: -this.padding() * 2,
+        y: 0
+      });
+      t.x += c.x, t.y += c.y, t.width += this.padding() * 2, this._movingAnchorName = this._movingAnchorName.replace("left", "right"), this._anchorDragOffset.x -= c.x, this._anchorDragOffset.y -= c.y;
+    } else if (this._movingAnchorName && t.width < 0 && this._movingAnchorName.indexOf("right") >= 0) {
+      const c = r.point({
+        x: this.padding() * 2,
+        y: 0
+      });
+      this._movingAnchorName = this._movingAnchorName.replace("right", "left"), this._anchorDragOffset.x -= c.x, this._anchorDragOffset.y -= c.y, t.width += this.padding() * 2;
+    }
+    if (this._movingAnchorName && t.height < 0 && this._movingAnchorName.indexOf("top") >= 0) {
+      const c = r.point({
+        x: 0,
+        y: -this.padding() * 2
+      });
+      t.x += c.x, t.y += c.y, this._movingAnchorName = this._movingAnchorName.replace("top", "bottom"), this._anchorDragOffset.x -= c.x, this._anchorDragOffset.y -= c.y, t.height += this.padding() * 2;
+    } else if (this._movingAnchorName && t.height < 0 && this._movingAnchorName.indexOf("bottom") >= 0) {
+      const c = r.point({
+        x: 0,
+        y: this.padding() * 2
+      });
+      this._movingAnchorName = this._movingAnchorName.replace("bottom", "top"), this._anchorDragOffset.x -= c.x, this._anchorDragOffset.y -= c.y, t.height += this.padding() * 2;
+    }
+    if (this.boundBoxFunc()) {
+      const c = this.boundBoxFunc()(i, t);
+      c ? t = c : O.warn("boundBoxFunc returned falsy. You should return new bound rect from it!");
+    }
+    const o = 1e7, s = new ct();
+    s.translate(i.x, i.y), s.rotate(i.rotation), s.scale(i.width / o, i.height / o);
+    const a = new ct(), d = t.width / o, l = t.height / o;
+    this.flipEnabled() === !1 ? (a.translate(t.x, t.y), a.rotate(t.rotation), a.translate(t.width < 0 ? t.width : 0, t.height < 0 ? t.height : 0), a.scale(Math.abs(d), Math.abs(l))) : (a.translate(t.x, t.y), a.rotate(t.rotation), a.scale(d, l));
+    const g = a.multiply(s.invert());
+    this._nodes.forEach((c) => {
+      var p;
+      if (!c.getStage())
+        return;
+      const f = c.getParent().getAbsoluteTransform(), S = c.getTransform().copy();
+      S.translate(c.offsetX(), c.offsetY());
+      const _ = new ct();
+      _.multiply(f.copy().invert()).multiply(g).multiply(f).multiply(S);
+      const b = _.decompose();
+      c.setAttrs(b), (p = c.getLayer()) === null || p === void 0 || p.batchDraw();
+    }), this.rotation(O._getRotation(t.rotation)), this._nodes.forEach((c) => {
+      this._fire("transform", { evt: e, target: c }), c._fire("transform", { evt: e, target: c });
+    }), this._resetTransformCache(), this.update(), this.getLayer().batchDraw();
+  }
+  forceUpdate() {
+    this._resetTransformCache(), this.update();
+  }
+  _batchChangeChild(t, e) {
+    this.findOne(t).setAttrs(e);
+  }
+  update() {
+    var t;
+    const e = this._getNodeRect();
+    this.rotation(O._getRotation(e.rotation));
+    const i = e.width, n = e.height, r = this.enabledAnchors(), o = this.resizeEnabled(), s = this.padding(), a = this.anchorSize(), d = this.find("._anchor");
+    d.forEach((M) => {
+      M.setAttrs({
+        width: a,
+        height: a,
+        offsetX: a / 2,
+        offsetY: a / 2,
+        stroke: this.anchorStroke(),
+        strokeWidth: this.anchorStrokeWidth(),
+        fill: this.anchorFill(),
+        cornerRadius: this.anchorCornerRadius()
+      });
+    }), this._batchChangeChild(".top-left", {
+      x: 0,
+      y: 0,
+      offsetX: a / 2 + s,
+      offsetY: a / 2 + s,
+      visible: o && r.indexOf("top-left") >= 0
+    }), this._batchChangeChild(".top-center", {
+      x: i / 2,
+      y: 0,
+      offsetY: a / 2 + s,
+      visible: o && r.indexOf("top-center") >= 0
+    }), this._batchChangeChild(".top-right", {
+      x: i,
+      y: 0,
+      offsetX: a / 2 - s,
+      offsetY: a / 2 + s,
+      visible: o && r.indexOf("top-right") >= 0
+    }), this._batchChangeChild(".middle-left", {
+      x: 0,
+      y: n / 2,
+      offsetX: a / 2 + s,
+      visible: o && r.indexOf("middle-left") >= 0
+    }), this._batchChangeChild(".middle-right", {
+      x: i,
+      y: n / 2,
+      offsetX: a / 2 - s,
+      visible: o && r.indexOf("middle-right") >= 0
+    }), this._batchChangeChild(".bottom-left", {
+      x: 0,
+      y: n,
+      offsetX: a / 2 + s,
+      offsetY: a / 2 - s,
+      visible: o && r.indexOf("bottom-left") >= 0
+    }), this._batchChangeChild(".bottom-center", {
+      x: i / 2,
+      y: n,
+      offsetY: a / 2 - s,
+      visible: o && r.indexOf("bottom-center") >= 0
+    }), this._batchChangeChild(".bottom-right", {
+      x: i,
+      y: n,
+      offsetX: a / 2 - s,
+      offsetY: a / 2 - s,
+      visible: o && r.indexOf("bottom-right") >= 0
+    });
+    const l = this.rotateAnchorAngle(), g = this.rotateAnchorOffset(), c = O.degToRad(l), p = Math.sin(c), f = -Math.cos(c), S = i / 2, _ = n / 2;
+    let b = 1 / 0;
+    f < 0 ? b = Math.min(b, -_ / f) : f > 0 && (b = Math.min(b, (n - _) / f)), p < 0 ? b = Math.min(b, -S / p) : p > 0 && (b = Math.min(b, (i - S) / p));
+    const m = S + p * b, x = _ + f * b, y = O._sign(n);
+    this._batchChangeChild(".rotater", {
+      x: m + p * g * y,
+      y: x + f * g * y - s * f,
+      visible: this.rotateEnabled()
+    }), this._batchChangeChild(".back", {
+      width: i,
+      height: n,
+      visible: this.borderEnabled(),
+      stroke: this.borderStroke(),
+      strokeWidth: this.borderStrokeWidth(),
+      dash: this.borderDash(),
+      draggable: this.nodes().some((M) => M.draggable()),
+      x: 0,
+      y: 0
+    });
+    const v = this.anchorStyleFunc();
+    v && d.forEach((M) => {
+      v(M);
+    }), (t = this.getLayer()) === null || t === void 0 || t.batchDraw();
+  }
+  isTransforming() {
+    return this._transforming;
+  }
+  stopTransform() {
+    if (this._transforming) {
+      this._removeEvents();
+      const t = this.findOne("." + this._movingAnchorName);
+      t && t.stopDrag();
+    }
+  }
+  destroy() {
+    return this.getStage() && this._cursorChange && this.getStage().content && (this.getStage().content.style.cursor = ""), At.prototype.destroy.call(this), this.detach(), this._removeEvents(), this;
+  }
+  add(...t) {
+    return this._elementsCreated ? (O.error("You cannot add external nodes to the Transformer. Use tr.nodes([node]) instead."), this) : super.add(...t);
+  }
+  toObject() {
+    return B.prototype.toObject.call(this);
+  }
+  clone(t) {
+    return B.prototype.clone.call(this, t);
+  }
+  getClientRect() {
+    return this.nodes().length > 0 ? super.getClientRect() : { x: 0, y: 0, width: 0, height: 0 };
+  }
+}
+N.isTransforming = () => Lt > 0;
+function De(h) {
+  return h instanceof Array || O.warn("enabledAnchors value should be an array"), h instanceof Array && h.forEach(function(t) {
+    bt.indexOf(t) === -1 && O.warn("Unknown anchor name: " + t + ". Available names are: " + bt.join(", "));
+  }), h || [];
+}
+N.prototype.className = "Transformer";
+V(N);
+u.addGetterSetter(N, "enabledAnchors", bt, De);
+u.addGetterSetter(N, "flipEnabled", !0, Gt());
+u.addGetterSetter(N, "resizeEnabled", !0);
+u.addGetterSetter(N, "anchorSize", 10, T());
+u.addGetterSetter(N, "rotateEnabled", !0);
+u.addGetterSetter(N, "rotateLineVisible", !0);
+u.addGetterSetter(N, "rotationSnaps", []);
+u.addGetterSetter(N, "rotateAnchorOffset", 50, T());
+u.addGetterSetter(N, "rotateAnchorAngle", 0, T());
+u.addGetterSetter(N, "rotateAnchorCursor", "crosshair");
+u.addGetterSetter(N, "rotationSnapTolerance", 5, T());
+u.addGetterSetter(N, "borderEnabled", !0);
+u.addGetterSetter(N, "anchorStroke", "rgb(0, 161, 255)");
+u.addGetterSetter(N, "anchorStrokeWidth", 1, T());
+u.addGetterSetter(N, "anchorFill", "white");
+u.addGetterSetter(N, "anchorCornerRadius", 0, T());
+u.addGetterSetter(N, "borderStroke", "rgb(0, 161, 255)");
+u.addGetterSetter(N, "borderStrokeWidth", 1, T());
+u.addGetterSetter(N, "borderDash");
+u.addGetterSetter(N, "keepRatio", !0);
+u.addGetterSetter(N, "shiftBehavior", "default");
+u.addGetterSetter(N, "centeredScaling", !1);
+u.addGetterSetter(N, "ignoreStroke", !1);
+u.addGetterSetter(N, "padding", 0, T());
+u.addGetterSetter(N, "nodes");
+u.addGetterSetter(N, "node");
+u.addGetterSetter(N, "boundBoxFunc");
+u.addGetterSetter(N, "anchorDragBoundFunc");
+u.addGetterSetter(N, "anchorStyleFunc");
+u.addGetterSetter(N, "shouldOverdrawWholeArea", !1);
+u.addGetterSetter(N, "useSingleNodeRotation", !0);
+u.backCompat(N, {
+  lineEnabled: "borderEnabled",
+  rotateHandlerOffset: "rotateAnchorOffset",
+  enabledHandlers: "enabledAnchors"
+});
+class et extends $ {
+  _sceneFunc(t) {
+    t.beginPath(), t.arc(0, 0, this.radius(), 0, j.getAngle(this.angle()), this.clockwise()), t.lineTo(0, 0), t.closePath(), t.fillStrokeShape(this);
+  }
+  getWidth() {
+    return this.radius() * 2;
+  }
+  getHeight() {
+    return this.radius() * 2;
+  }
+  setWidth(t) {
+    this.radius(t / 2);
+  }
+  setHeight(t) {
+    this.radius(t / 2);
+  }
+}
+et.prototype.className = "Wedge";
+et.prototype._centroid = !0;
+et.prototype._attrsAffectingSize = ["radius"];
+V(et);
+u.addGetterSetter(et, "radius", 0, T());
+u.addGetterSetter(et, "angle", 0, T());
+u.addGetterSetter(et, "clockwise", !1);
+u.backCompat(et, {
+  angleDeg: "angle",
+  getAngleDeg: "getAngle",
+  setAngleDeg: "setAngle"
+});
+function qt() {
+  this.r = 0, this.g = 0, this.b = 0, this.a = 0, this.next = null;
+}
+const He = [
+  512,
+  512,
+  456,
+  512,
+  328,
+  456,
+  335,
+  512,
+  405,
+  328,
+  271,
+  456,
+  388,
+  335,
+  292,
+  512,
+  454,
+  405,
+  364,
+  328,
+  298,
+  271,
+  496,
+  456,
+  420,
+  388,
+  360,
+  335,
+  312,
+  292,
+  273,
+  512,
+  482,
+  454,
+  428,
+  405,
+  383,
+  364,
+  345,
+  328,
+  312,
+  298,
+  284,
+  271,
+  259,
+  496,
+  475,
+  456,
+  437,
+  420,
+  404,
+  388,
+  374,
+  360,
+  347,
+  335,
+  323,
+  312,
+  302,
+  292,
+  282,
+  273,
+  265,
+  512,
+  497,
+  482,
+  468,
+  454,
+  441,
+  428,
+  417,
+  405,
+  394,
+  383,
+  373,
+  364,
+  354,
+  345,
+  337,
+  328,
+  320,
+  312,
+  305,
+  298,
+  291,
+  284,
+  278,
+  271,
+  265,
+  259,
+  507,
+  496,
+  485,
+  475,
+  465,
+  456,
+  446,
+  437,
+  428,
+  420,
+  412,
+  404,
+  396,
+  388,
+  381,
+  374,
+  367,
+  360,
+  354,
+  347,
+  341,
+  335,
+  329,
+  323,
+  318,
+  312,
+  307,
+  302,
+  297,
+  292,
+  287,
+  282,
+  278,
+  273,
+  269,
+  265,
+  261,
+  512,
+  505,
+  497,
+  489,
+  482,
+  475,
+  468,
+  461,
+  454,
+  447,
+  441,
+  435,
+  428,
+  422,
+  417,
+  411,
+  405,
+  399,
+  394,
+  389,
+  383,
+  378,
+  373,
+  368,
+  364,
+  359,
+  354,
+  350,
+  345,
+  341,
+  337,
+  332,
+  328,
+  324,
+  320,
+  316,
+  312,
+  309,
+  305,
+  301,
+  298,
+  294,
+  291,
+  287,
+  284,
+  281,
+  278,
+  274,
+  271,
+  268,
+  265,
+  262,
+  259,
+  257,
+  507,
+  501,
+  496,
+  491,
+  485,
+  480,
+  475,
+  470,
+  465,
+  460,
+  456,
+  451,
+  446,
+  442,
+  437,
+  433,
+  428,
+  424,
+  420,
+  416,
+  412,
+  408,
+  404,
+  400,
+  396,
+  392,
+  388,
+  385,
+  381,
+  377,
+  374,
+  370,
+  367,
+  363,
+  360,
+  357,
+  354,
+  350,
+  347,
+  344,
+  341,
+  338,
+  335,
+  332,
+  329,
+  326,
+  323,
+  320,
+  318,
+  315,
+  312,
+  310,
+  307,
+  304,
+  302,
+  299,
+  297,
+  294,
+  292,
+  289,
+  287,
+  285,
+  282,
+  280,
+  278,
+  275,
+  273,
+  271,
+  269,
+  267,
+  265,
+  263,
+  261,
+  259
+], Xe = [
+  9,
+  11,
+  12,
+  13,
+  13,
+  14,
+  14,
+  15,
+  15,
+  15,
+  15,
+  16,
+  16,
+  16,
+  16,
+  17,
+  17,
+  17,
+  17,
+  17,
+  17,
+  17,
+  18,
+  18,
+  18,
+  18,
+  18,
+  18,
+  18,
+  18,
+  18,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  19,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  20,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  21,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  22,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  23,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24
+];
+function Ye(h, t) {
+  const e = h.data, i = h.width, n = h.height;
+  let r, o, s, a, d, l, g, c, p, f, S, _, b, m, x, y, v, M, C, A;
+  const k = t + t + 1, G = i - 1, I = n - 1, P = t + 1, F = P * (P + 1) / 2, E = new qt(), L = He[t], w = Xe[t];
+  let D = null, R = E, W = null, U = null;
+  for (let z = 1; z < k; z++)
+    R = R.next = new qt(), z === P && (D = R);
+  R.next = E, s = o = 0;
+  for (let z = 0; z < n; z++) {
+    _ = b = m = x = a = d = l = g = 0, c = P * (y = e[o]), p = P * (v = e[o + 1]), f = P * (M = e[o + 2]), S = P * (C = e[o + 3]), a += F * y, d += F * v, l += F * M, g += F * C, R = E;
+    for (let Y = 0; Y < P; Y++)
+      R.r = y, R.g = v, R.b = M, R.a = C, R = R.next;
+    for (let Y = 1; Y < P; Y++)
+      r = o + ((G < Y ? G : Y) << 2), a += (R.r = y = e[r]) * (A = P - Y), d += (R.g = v = e[r + 1]) * A, l += (R.b = M = e[r + 2]) * A, g += (R.a = C = e[r + 3]) * A, _ += y, b += v, m += M, x += C, R = R.next;
+    W = E, U = D;
+    for (let Y = 0; Y < i; Y++)
+      e[o + 3] = C = g * L >> w, C !== 0 ? (C = 255 / C, e[o] = (a * L >> w) * C, e[o + 1] = (d * L >> w) * C, e[o + 2] = (l * L >> w) * C) : e[o] = e[o + 1] = e[o + 2] = 0, a -= c, d -= p, l -= f, g -= S, c -= W.r, p -= W.g, f -= W.b, S -= W.a, r = s + ((r = Y + t + 1) < G ? r : G) << 2, _ += W.r = e[r], b += W.g = e[r + 1], m += W.b = e[r + 2], x += W.a = e[r + 3], a += _, d += b, l += m, g += x, W = W.next, c += y = U.r, p += v = U.g, f += M = U.b, S += C = U.a, _ -= y, b -= v, m -= M, x -= C, U = U.next, o += 4;
+    s += i;
+  }
+  for (let z = 0; z < i; z++) {
+    b = m = x = _ = d = l = g = a = 0, o = z << 2, c = P * (y = e[o]), p = P * (v = e[o + 1]), f = P * (M = e[o + 2]), S = P * (C = e[o + 3]), a += F * y, d += F * v, l += F * M, g += F * C, R = E;
+    for (let Q = 0; Q < P; Q++)
+      R.r = y, R.g = v, R.b = M, R.a = C, R = R.next;
+    let Y = i;
+    for (let Q = 1; Q <= t; Q++)
+      o = Y + z << 2, a += (R.r = y = e[o]) * (A = P - Q), d += (R.g = v = e[o + 1]) * A, l += (R.b = M = e[o + 2]) * A, g += (R.a = C = e[o + 3]) * A, _ += y, b += v, m += M, x += C, R = R.next, Q < I && (Y += i);
+    o = z, W = E, U = D;
+    for (let Q = 0; Q < n; Q++)
+      r = o << 2, e[r + 3] = C = g * L >> w, C > 0 ? (C = 255 / C, e[r] = (a * L >> w) * C, e[r + 1] = (d * L >> w) * C, e[r + 2] = (l * L >> w) * C) : e[r] = e[r + 1] = e[r + 2] = 0, a -= c, d -= p, l -= f, g -= S, c -= W.r, p -= W.g, f -= W.b, S -= W.a, r = z + ((r = Q + P) < I ? r : I) * i << 2, a += _ += W.r = e[r], d += b += W.g = e[r + 1], l += m += W.b = e[r + 2], g += x += W.a = e[r + 3], W = W.next, c += y = U.r, p += v = U.g, f += M = U.b, S += C = U.a, _ -= y, b -= v, m -= M, x -= C, U = U.next, o += i;
+  }
+}
+const qe = function(t) {
+  const e = Math.round(this.blurRadius());
+  e > 0 && Ye(t, e);
+};
+u.addGetterSetter(B, "blurRadius", 0, T(), u.afterSetFilter);
+const Ue = function(h) {
+  const t = this.brightness() * 255, e = h.data, i = e.length;
+  for (let n = 0; n < i; n += 4)
+    e[n] += t, e[n + 1] += t, e[n + 2] += t;
+};
+u.addGetterSetter(B, "brightness", 0, T(), u.afterSetFilter);
+const je = function(h) {
+  const t = this.brightness(), e = h.data, i = e.length;
+  for (let n = 0; n < i; n += 4)
+    e[n] = Math.min(255, e[n] * t), e[n + 1] = Math.min(255, e[n + 1] * t), e[n + 2] = Math.min(255, e[n + 2] * t);
+}, Ve = function(h) {
+  const t = Math.pow((this.contrast() + 100) / 100, 2), e = h.data, i = e.length;
+  let n = 150, r = 150, o = 150;
+  for (let s = 0; s < i; s += 4)
+    n = e[s], r = e[s + 1], o = e[s + 2], n /= 255, n -= 0.5, n *= t, n += 0.5, n *= 255, r /= 255, r -= 0.5, r *= t, r += 0.5, r *= 255, o /= 255, o -= 0.5, o *= t, o += 0.5, o *= 255, n = n < 0 ? 0 : n > 255 ? 255 : n, r = r < 0 ? 0 : r > 255 ? 255 : r, o = o < 0 ? 0 : o > 255 ? 255 : o, e[s] = n, e[s + 1] = r, e[s + 2] = o;
+};
+u.addGetterSetter(B, "contrast", 0, T(), u.afterSetFilter);
+const $e = function(h) {
+  var t, e, i, n, r, o, s, a, d;
+  const l = h.data, g = h.width, c = h.height, p = Math.min(1, Math.max(0, (e = (t = this.embossStrength) === null || t === void 0 ? void 0 : t.call(this)) !== null && e !== void 0 ? e : 0.5)), f = Math.min(1, Math.max(0, (n = (i = this.embossWhiteLevel) === null || i === void 0 ? void 0 : i.call(this)) !== null && n !== void 0 ? n : 0.5)), _ = (s = {
+    "top-left": 315,
+    top: 270,
+    "top-right": 225,
+    right: 180,
+    "bottom-right": 135,
+    bottom: 90,
+    "bottom-left": 45,
+    left: 0
+  }[(o = (r = this.embossDirection) === null || r === void 0 ? void 0 : r.call(this)) !== null && o !== void 0 ? o : "top-left"]) !== null && s !== void 0 ? s : 315, b = !!((d = (a = this.embossBlend) === null || a === void 0 ? void 0 : a.call(this)) !== null && d !== void 0 && d), m = p * 10, x = f * 255, y = _ * Math.PI / 180, v = Math.cos(y), M = Math.sin(y), C = 128 / 1020 * m, A = new Uint8ClampedArray(l), k = new Float32Array(g * c);
+  for (let E = 0, L = 0; L < l.length; L += 4, E++)
+    k[E] = 0.2126 * A[L] + 0.7152 * A[L + 1] + 0.0722 * A[L + 2];
+  const G = [-1, 0, 1, -2, 0, 2, -1, 0, 1], I = [-1, -2, -1, 0, 0, 0, 1, 2, 1], P = [-g - 1, -g, -g + 1, -1, 0, 1, g - 1, g, g + 1], F = (E) => E < 0 ? 0 : E > 255 ? 255 : E;
+  for (let E = 1; E < c - 1; E++)
+    for (let L = 1; L < g - 1; L++) {
+      const w = E * g + L;
+      let D = 0, R = 0;
+      D += k[w + P[0]] * G[0], R += k[w + P[0]] * I[0], D += k[w + P[1]] * G[1], R += k[w + P[1]] * I[1], D += k[w + P[2]] * G[2], R += k[w + P[2]] * I[2], D += k[w + P[3]] * G[3], R += k[w + P[3]] * I[3], D += k[w + P[5]] * G[5], R += k[w + P[5]] * I[5], D += k[w + P[6]] * G[6], R += k[w + P[6]] * I[6], D += k[w + P[7]] * G[7], R += k[w + P[7]] * I[7], D += k[w + P[8]] * G[8], R += k[w + P[8]] * I[8];
+      const W = v * D + M * R, U = F(x + W * C), z = w * 4;
+      if (b) {
+        const Y = U - x;
+        l[z] = F(A[z] + Y), l[z + 1] = F(A[z + 1] + Y), l[z + 2] = F(A[z + 2] + Y), l[z + 3] = A[z + 3];
+      } else
+        l[z] = l[z + 1] = l[z + 2] = U, l[z + 3] = A[z + 3];
+    }
+  for (let E = 0; E < g; E++) {
+    let L = E * 4, w = ((c - 1) * g + E) * 4;
+    l[L] = A[L], l[L + 1] = A[L + 1], l[L + 2] = A[L + 2], l[L + 3] = A[L + 3], l[w] = A[w], l[w + 1] = A[w + 1], l[w + 2] = A[w + 2], l[w + 3] = A[w + 3];
+  }
+  for (let E = 1; E < c - 1; E++) {
+    let L = E * g * 4, w = (E * g + (g - 1)) * 4;
+    l[L] = A[L], l[L + 1] = A[L + 1], l[L + 2] = A[L + 2], l[L + 3] = A[L + 3], l[w] = A[w], l[w + 1] = A[w + 1], l[w + 2] = A[w + 2], l[w + 3] = A[w + 3];
+  }
+  return h;
+};
+u.addGetterSetter(B, "embossStrength", 0.5, T(), u.afterSetFilter);
+u.addGetterSetter(B, "embossWhiteLevel", 0.5, T(), u.afterSetFilter);
+u.addGetterSetter(B, "embossDirection", "top-left", void 0, u.afterSetFilter);
+u.addGetterSetter(B, "embossBlend", !1, void 0, u.afterSetFilter);
+function vt(h, t, e, i, n) {
+  const r = e - t, o = n - i;
+  if (r === 0)
+    return i + o / 2;
+  if (o === 0)
+    return i;
+  let s = (h - t) / r;
+  return s = o * s + i, s;
+}
+const Qe = function(h) {
+  const t = h.data, e = t.length;
+  let i = t[0], n = i, r, o = t[1], s = o, a, d = t[2], l = d, g;
+  const c = this.enhance();
+  if (c === 0)
+    return;
+  for (let x = 0; x < e; x += 4)
+    r = t[x + 0], r < i ? i = r : r > n && (n = r), a = t[x + 1], a < o ? o = a : a > s && (s = a), g = t[x + 2], g < d ? d = g : g > l && (l = g);
+  n === i && (n = 255, i = 0), s === o && (s = 255, o = 0), l === d && (l = 255, d = 0);
+  let p, f, S, _, b, m;
+  if (c > 0)
+    p = n + c * (255 - n), f = i - c * (i - 0), S = s + c * (255 - s), _ = o - c * (o - 0), b = l + c * (255 - l), m = d - c * (d - 0);
+  else {
+    const x = (n + i) * 0.5;
+    p = n + c * (n - x), f = i + c * (i - x);
+    const y = (s + o) * 0.5;
+    S = s + c * (s - y), _ = o + c * (o - y);
+    const v = (l + d) * 0.5;
+    b = l + c * (l - v), m = d + c * (d - v);
+  }
+  for (let x = 0; x < e; x += 4)
+    t[x + 0] = vt(t[x + 0], i, n, f, p), t[x + 1] = vt(t[x + 1], o, s, _, S), t[x + 2] = vt(t[x + 2], d, l, m, b);
+};
+u.addGetterSetter(B, "enhance", 0, T(), u.afterSetFilter);
+const Ke = function(h) {
+  const t = h.data, e = t.length;
+  for (let i = 0; i < e; i += 4) {
+    const n = 0.34 * t[i] + 0.5 * t[i + 1] + 0.16 * t[i + 2];
+    t[i] = n, t[i + 1] = n, t[i + 2] = n;
+  }
+};
+u.addGetterSetter(B, "hue", 0, T(), u.afterSetFilter);
+u.addGetterSetter(B, "saturation", 0, T(), u.afterSetFilter);
+u.addGetterSetter(B, "luminance", 0, T(), u.afterSetFilter);
+const Ze = function(h) {
+  const t = h.data, e = t.length, i = 1, n = Math.pow(2, this.saturation()), r = Math.abs(this.hue() + 360) % 360, o = this.luminance() * 127, s = i * n * Math.cos(r * Math.PI / 180), a = i * n * Math.sin(r * Math.PI / 180), d = 0.299 * i + 0.701 * s + 0.167 * a, l = 0.587 * i - 0.587 * s + 0.33 * a, g = 0.114 * i - 0.114 * s - 0.497 * a, c = 0.299 * i - 0.299 * s - 0.328 * a, p = 0.587 * i + 0.413 * s + 0.035 * a, f = 0.114 * i - 0.114 * s + 0.293 * a, S = 0.299 * i - 0.3 * s + 1.25 * a, _ = 0.587 * i - 0.586 * s - 1.05 * a, b = 0.114 * i + 0.886 * s - 0.2 * a;
+  let m, x, y, v;
+  for (let M = 0; M < e; M += 4)
+    m = t[M + 0], x = t[M + 1], y = t[M + 2], v = t[M + 3], t[M + 0] = d * m + l * x + g * y + o, t[M + 1] = c * m + p * x + f * y + o, t[M + 2] = S * m + _ * x + b * y + o, t[M + 3] = v;
+}, Je = function(h) {
+  const t = h.data, e = t.length, i = Math.pow(2, this.value()), n = Math.pow(2, this.saturation()), r = Math.abs(this.hue() + 360) % 360, o = i * n * Math.cos(r * Math.PI / 180), s = i * n * Math.sin(r * Math.PI / 180), a = 0.299 * i + 0.701 * o + 0.167 * s, d = 0.587 * i - 0.587 * o + 0.33 * s, l = 0.114 * i - 0.114 * o - 0.497 * s, g = 0.299 * i - 0.299 * o - 0.328 * s, c = 0.587 * i + 0.413 * o + 0.035 * s, p = 0.114 * i - 0.114 * o + 0.293 * s, f = 0.299 * i - 0.3 * o + 1.25 * s, S = 0.587 * i - 0.586 * o - 1.05 * s, _ = 0.114 * i + 0.886 * o - 0.2 * s;
+  for (let b = 0; b < e; b += 4) {
+    const m = t[b + 0], x = t[b + 1], y = t[b + 2], v = t[b + 3];
+    t[b + 0] = a * m + d * x + l * y, t[b + 1] = g * m + c * x + p * y, t[b + 2] = f * m + S * x + _ * y, t[b + 3] = v;
+  }
+};
+u.addGetterSetter(B, "hue", 0, T(), u.afterSetFilter);
+u.addGetterSetter(B, "saturation", 0, T(), u.afterSetFilter);
+u.addGetterSetter(B, "value", 0, T(), u.afterSetFilter);
+const t0 = function(h) {
+  const t = h.data, e = t.length;
+  for (let i = 0; i < e; i += 4)
+    t[i] = 255 - t[i], t[i + 1] = 255 - t[i + 1], t[i + 2] = 255 - t[i + 2];
+}, e0 = function(h, t, e) {
+  const i = h.data, n = t.data, r = h.width, o = h.height, s = e.polarCenterX || r / 2, a = e.polarCenterY || o / 2;
+  let d = Math.sqrt(s * s + a * a), l = r - s, g = o - a;
+  const c = Math.sqrt(l * l + g * g);
+  d = c > d ? c : d;
+  const p = o, f = r, S = 360 / f * Math.PI / 180;
+  for (let _ = 0; _ < f; _ += 1) {
+    const b = Math.sin(_ * S), m = Math.cos(_ * S);
+    for (let x = 0; x < p; x += 1) {
+      l = Math.floor(s + d * x / p * m), g = Math.floor(a + d * x / p * b);
+      let y = (g * r + l) * 4;
+      const v = i[y + 0], M = i[y + 1], C = i[y + 2], A = i[y + 3];
+      y = (_ + x * r) * 4, n[y + 0] = v, n[y + 1] = M, n[y + 2] = C, n[y + 3] = A;
+    }
+  }
+}, i0 = function(h, t, e) {
+  const i = h.data, n = t.data, r = h.width, o = h.height, s = e.polarCenterX || r / 2, a = e.polarCenterY || o / 2;
+  let d = Math.sqrt(s * s + a * a), l = r - s, g = o - a;
+  const c = Math.sqrt(l * l + g * g);
+  d = c > d ? c : d;
+  const p = o, f = r, S = 0;
+  let _, b;
+  for (l = 0; l < r; l += 1)
+    for (g = 0; g < o; g += 1) {
+      const m = l - s, x = g - a, y = Math.sqrt(m * m + x * x) * p / d;
+      let v = (Math.atan2(x, m) * 180 / Math.PI + 360 + S) % 360;
+      v = v * f / 360, _ = Math.floor(v), b = Math.floor(y);
+      let M = (b * r + _) * 4;
+      const C = i[M + 0], A = i[M + 1], k = i[M + 2], G = i[M + 3];
+      M = (g * r + l) * 4, n[M + 0] = C, n[M + 1] = A, n[M + 2] = k, n[M + 3] = G;
+    }
+}, n0 = function(h) {
+  const t = h.width, e = h.height;
+  let i, n, r, o, s, a, d, l, g, c, p = Math.round(this.kaleidoscopePower());
+  const f = Math.round(this.kaleidoscopeAngle()), S = Math.floor(t * (f % 360) / 360);
+  if (p < 1)
+    return;
+  const _ = O.createCanvasElement();
+  _.width = t, _.height = e;
+  const b = _.getContext("2d").getImageData(0, 0, t, e);
+  O.releaseCanvas(_), e0(h, b, {
+    polarCenterX: t / 2,
+    polarCenterY: e / 2
+  });
+  let m = t / Math.pow(2, p);
+  for (; m <= 8; )
+    m = m * 2, p -= 1;
+  m = Math.ceil(m);
+  let x = m, y = 0, v = x, M = 1;
+  for (S + m > t && (y = x, v = 0, M = -1), n = 0; n < e; n += 1)
+    for (i = y; i !== v; i += M)
+      r = Math.round(i + S) % t, g = (t * n + r) * 4, s = b.data[g + 0], a = b.data[g + 1], d = b.data[g + 2], l = b.data[g + 3], c = (t * n + i) * 4, b.data[c + 0] = s, b.data[c + 1] = a, b.data[c + 2] = d, b.data[c + 3] = l;
+  for (n = 0; n < e; n += 1)
+    for (x = Math.floor(m), o = 0; o < p; o += 1) {
+      for (i = 0; i < x + 1; i += 1)
+        g = (t * n + i) * 4, s = b.data[g + 0], a = b.data[g + 1], d = b.data[g + 2], l = b.data[g + 3], c = (t * n + x * 2 - i - 1) * 4, b.data[c + 0] = s, b.data[c + 1] = a, b.data[c + 2] = d, b.data[c + 3] = l;
+      x *= 2;
+    }
+  i0(b, h, {});
+};
+u.addGetterSetter(B, "kaleidoscopePower", 2, T(), u.afterSetFilter);
+u.addGetterSetter(B, "kaleidoscopeAngle", 0, T(), u.afterSetFilter);
+function _t(h, t, e) {
+  let i = (e * h.width + t) * 4;
+  const n = [];
+  return n.push(h.data[i++], h.data[i++], h.data[i++], h.data[i++]), n;
+}
+function ut(h, t) {
+  return Math.sqrt(Math.pow(h[0] - t[0], 2) + Math.pow(h[1] - t[1], 2) + Math.pow(h[2] - t[2], 2));
+}
+function s0(h) {
+  const t = [0, 0, 0];
+  for (let e = 0; e < h.length; e++)
+    t[0] += h[e][0], t[1] += h[e][1], t[2] += h[e][2];
+  return t[0] /= h.length, t[1] /= h.length, t[2] /= h.length, t;
+}
+function r0(h, t) {
+  const e = _t(h, 0, 0), i = _t(h, h.width - 1, 0), n = _t(h, 0, h.height - 1), r = _t(h, h.width - 1, h.height - 1), o = t || 10;
+  if (ut(e, i) < o && ut(i, r) < o && ut(r, n) < o && ut(n, e) < o) {
+    const s = s0([i, e, r, n]), a = [];
+    for (let d = 0; d < h.width * h.height; d++) {
+      const l = ut(s, [
+        h.data[d * 4],
+        h.data[d * 4 + 1],
+        h.data[d * 4 + 2]
+      ]);
+      a[d] = l < o ? 0 : 255;
+    }
+    return a;
+  }
+}
+function o0(h, t) {
+  for (let e = 0; e < h.width * h.height; e++)
+    h.data[4 * e + 3] = t[e];
+}
+function a0(h, t, e) {
+  const i = [1, 1, 1, 1, 0, 1, 1, 1, 1], n = Math.round(Math.sqrt(i.length)), r = Math.floor(n / 2), o = [];
+  for (let s = 0; s < e; s++)
+    for (let a = 0; a < t; a++) {
+      const d = s * t + a;
+      let l = 0;
+      for (let g = 0; g < n; g++)
+        for (let c = 0; c < n; c++) {
+          const p = s + g - r, f = a + c - r;
+          if (p >= 0 && p < e && f >= 0 && f < t) {
+            const S = p * t + f, _ = i[g * n + c];
+            l += h[S] * _;
+          }
+        }
+      o[d] = l === 2040 ? 255 : 0;
+    }
+  return o;
+}
+function h0(h, t, e) {
+  const i = [1, 1, 1, 1, 1, 1, 1, 1, 1], n = Math.round(Math.sqrt(i.length)), r = Math.floor(n / 2), o = [];
+  for (let s = 0; s < e; s++)
+    for (let a = 0; a < t; a++) {
+      const d = s * t + a;
+      let l = 0;
+      for (let g = 0; g < n; g++)
+        for (let c = 0; c < n; c++) {
+          const p = s + g - r, f = a + c - r;
+          if (p >= 0 && p < e && f >= 0 && f < t) {
+            const S = p * t + f, _ = i[g * n + c];
+            l += h[S] * _;
+          }
+        }
+      o[d] = l >= 1020 ? 255 : 0;
+    }
+  return o;
+}
+function l0(h, t, e) {
+  const i = [
+    0.1111111111111111,
+    0.1111111111111111,
+    0.1111111111111111,
+    0.1111111111111111,
+    0.1111111111111111,
+    0.1111111111111111,
+    0.1111111111111111,
+    0.1111111111111111,
+    0.1111111111111111
+  ], n = Math.round(Math.sqrt(i.length)), r = Math.floor(n / 2), o = [];
+  for (let s = 0; s < e; s++)
+    for (let a = 0; a < t; a++) {
+      const d = s * t + a;
+      let l = 0;
+      for (let g = 0; g < n; g++)
+        for (let c = 0; c < n; c++) {
+          const p = s + g - r, f = a + c - r;
+          if (p >= 0 && p < e && f >= 0 && f < t) {
+            const S = p * t + f, _ = i[g * n + c];
+            l += h[S] * _;
+          }
+        }
+      o[d] = l;
+    }
+  return o;
+}
+const d0 = function(h) {
+  const t = this.threshold();
+  let e = r0(h, t);
+  return e && (e = a0(e, h.width, h.height), e = h0(e, h.width, h.height), e = l0(e, h.width, h.height), o0(h, e)), h;
+};
+u.addGetterSetter(B, "threshold", 0, T(), u.afterSetFilter);
+const c0 = function(h) {
+  const t = this.noise() * 255, e = h.data, i = e.length, n = t / 2;
+  for (let r = 0; r < i; r += 4)
+    e[r + 0] += n - 2 * n * Math.random(), e[r + 1] += n - 2 * n * Math.random(), e[r + 2] += n - 2 * n * Math.random();
+};
+u.addGetterSetter(B, "noise", 0.2, T(), u.afterSetFilter);
+const f0 = function(h) {
+  let t = Math.ceil(this.pixelSize()), e = h.width, i = h.height, n = Math.ceil(e / t), r = Math.ceil(i / t), o = h.data;
+  if (t <= 0) {
+    O.error("pixelSize value can not be <= 0");
+    return;
+  }
+  for (let s = 0; s < n; s += 1)
+    for (let a = 0; a < r; a += 1) {
+      let d = 0, l = 0, g = 0, c = 0;
+      const p = s * t, f = p + t, S = a * t, _ = S + t;
+      let b = 0;
+      for (let m = p; m < f; m += 1)
+        if (!(m >= e))
+          for (let x = S; x < _; x += 1) {
+            if (x >= i)
+              continue;
+            const y = (e * x + m) * 4;
+            d += o[y + 0], l += o[y + 1], g += o[y + 2], c += o[y + 3], b += 1;
+          }
+      d = d / b, l = l / b, g = g / b, c = c / b;
+      for (let m = p; m < f; m += 1)
+        if (!(m >= e))
+          for (let x = S; x < _; x += 1) {
+            if (x >= i)
+              continue;
+            const y = (e * x + m) * 4;
+            o[y + 0] = d, o[y + 1] = l, o[y + 2] = g, o[y + 3] = c;
+          }
+    }
+};
+u.addGetterSetter(B, "pixelSize", 8, T(), u.afterSetFilter);
+const g0 = function(h) {
+  const t = Math.round(this.levels() * 254) + 1, e = h.data, i = e.length, n = 255 / t;
+  for (let r = 0; r < i; r += 1)
+    e[r] = Math.floor(e[r] / n) * n;
+};
+u.addGetterSetter(B, "levels", 0.5, T(), u.afterSetFilter);
+const u0 = function(h) {
+  const t = h.data, e = t.length, i = this.red(), n = this.green(), r = this.blue();
+  for (let o = 0; o < e; o += 4) {
+    const s = (0.34 * t[o] + 0.5 * t[o + 1] + 0.16 * t[o + 2]) / 255;
+    t[o] = s * i, t[o + 1] = s * n, t[o + 2] = s * r, t[o + 3] = t[o + 3];
+  }
+};
+u.addGetterSetter(B, "red", 0, function(h) {
+  return this._filterUpToDate = !1, h > 255 ? 255 : h < 0 ? 0 : Math.round(h);
+});
+u.addGetterSetter(B, "green", 0, function(h) {
+  return this._filterUpToDate = !1, h > 255 ? 255 : h < 0 ? 0 : Math.round(h);
+});
+u.addGetterSetter(B, "blue", 0, jt, u.afterSetFilter);
+const p0 = function(h) {
+  const t = h.data, e = t.length, i = this.red(), n = this.green(), r = this.blue(), o = this.alpha();
+  for (let s = 0; s < e; s += 4) {
+    const a = 1 - o;
+    t[s] = i * o + t[s] * a, t[s + 1] = n * o + t[s + 1] * a, t[s + 2] = r * o + t[s + 2] * a;
+  }
+};
+u.addGetterSetter(B, "red", 0, function(h) {
+  return this._filterUpToDate = !1, h > 255 ? 255 : h < 0 ? 0 : Math.round(h);
+});
+u.addGetterSetter(B, "green", 0, function(h) {
+  return this._filterUpToDate = !1, h > 255 ? 255 : h < 0 ? 0 : Math.round(h);
+});
+u.addGetterSetter(B, "blue", 0, jt, u.afterSetFilter);
+u.addGetterSetter(B, "alpha", 1, function(h) {
+  return this._filterUpToDate = !1, h > 1 ? 1 : h < 0 ? 0 : h;
+});
+const m0 = function(h) {
+  const t = h.data, e = t.length;
+  for (let i = 0; i < e; i += 4) {
+    const n = t[i + 0], r = t[i + 1], o = t[i + 2];
+    t[i + 0] = Math.min(255, n * 0.393 + r * 0.769 + o * 0.189), t[i + 1] = Math.min(255, n * 0.349 + r * 0.686 + o * 0.168), t[i + 2] = Math.min(255, n * 0.272 + r * 0.534 + o * 0.131);
+  }
+}, S0 = function(h) {
+  const e = h.data;
+  for (let i = 0; i < e.length; i += 4) {
+    const n = e[i], r = e[i + 1], o = e[i + 2];
+    0.2126 * n + 0.7152 * r + 0.0722 * o >= 128 && (e[i] = 255 - n, e[i + 1] = 255 - r, e[i + 2] = 255 - o);
+  }
+  return h;
+}, _0 = function(h) {
+  const t = this.threshold() * 255, e = h.data, i = e.length;
+  for (let n = 0; n < i; n += 1)
+    e[n] = e[n] < t ? 0 : 255;
+};
+u.addGetterSetter(B, "threshold", 0.5, T(), u.afterSetFilter);
+const y0 = Et.Util._assign(Et, {
+  Arc: J,
+  Arrow: ot,
+  Circle: dt,
+  Ellipse: nt,
+  Image: K,
+  Label: Ot,
+  Tag: at,
+  Line: tt,
+  Path: H,
+  Rect: pt,
+  RegularPolygon: st,
+  Ring: ht,
+  Sprite: Z,
+  Star: rt,
+  Text: X,
+  TextPath: q,
+  Transformer: N,
+  Wedge: et,
+  Filters: {
+    Blur: qe,
+    Brightness: je,
+    Brighten: Ue,
+    Contrast: Ve,
+    Emboss: $e,
+    Enhance: Qe,
+    Grayscale: Ke,
+    HSL: Ze,
+    HSV: Je,
+    Invert: t0,
+    Kaleidoscope: n0,
+    Mask: d0,
+    Noise: c0,
+    Pixelate: f0,
+    Posterize: g0,
+    RGB: u0,
+    RGBA: p0,
+    Sepia: m0,
+    Solarize: S0,
+    Threshold: _0
+  }
+});
+export {
+  y0 as default
+};