@camstack/addon-pipeline-orchestrator 0.1.16 → 0.1.18

package/dist/_CoreInternals-B7PHssO3.mjs

@@ -0,0 +1,3808 @@
+const de = Math.PI / 180;
+function ue() {
+  return typeof window < "u" && ({}.toString.call(window) === "[object Window]" || {}.toString.call(window) === "[object global]");
+}
+const B = typeof global < "u" ? global : typeof window < "u" ? window : typeof WorkerGlobalScope < "u" ? self : {}, m = {
+  _global: B,
+  version: "10.3.0",
+  isBrowser: ue(),
+  isUnminified: /param/.test(function(n) {
+  }.toString()),
+  dblClickWindow: 400,
+  getAngle(n) {
+    return m.angleDeg ? n * de : n;
+  },
+  enableTrace: !1,
+  pointerEventsEnabled: !0,
+  autoDrawEnabled: !0,
+  hitOnDragEnabled: !1,
+  capturePointerEventsEnabled: !1,
+  _mouseListenClick: !1,
+  _touchListenClick: !1,
+  _pointerListenClick: !1,
+  _mouseInDblClickWindow: !1,
+  _touchInDblClickWindow: !1,
+  _pointerInDblClickWindow: !1,
+  _mouseDblClickPointerId: null,
+  _touchDblClickPointerId: null,
+  _pointerDblClickPointerId: null,
+  _renderBackend: "web",
+  legacyTextRendering: !1,
+  pixelRatio: typeof window < "u" && window.devicePixelRatio || 1,
+  dragDistance: 3,
+  angleDeg: !0,
+  showWarnings: !0,
+  dragButtons: [0, 1],
+  isDragging() {
+    return m.DD.isDragging;
+  },
+  isTransforming() {
+    var n, t;
+    return (t = (n = m.Transformer) === null || n === void 0 ? void 0 : n.isTransforming()) !== null && t !== void 0 ? t : !1;
+  },
+  isDragReady() {
+    return !!m.DD.node;
+  },
+  releaseCanvasOnDestroy: !0,
+  document: B.document,
+  _injectGlobal(n) {
+    typeof B.Konva < "u" && console.error("Several Konva instances detected. It is not recommended to use multiple Konva instances in the same environment."), B.Konva = n;
+  }
+}, nt = (n) => {
+  m[n.prototype.getClassName()] = n;
+};
+m._injectGlobal(m);
+const fe = `Konva.js unsupported environment.
+
+Looks like you are trying to use Konva.js in Node.js environment. because "document" object is undefined.
+
+To use Konva.js in Node.js environment, you need to use the "canvas-backend" or "skia-backend" module.
+
+bash: npm install canvas
+js: import "konva/canvas-backend";
+
+or
+
+bash: npm install skia-canvas
+js: import "konva/skia-backend";
+`, At = () => {
+  if (typeof document > "u")
+    throw new Error(fe);
+};
+class L {
+  constructor(t = [1, 0, 0, 1, 0, 0]) {
+    this.dirty = !1, this.m = t && t.slice() || [1, 0, 0, 1, 0, 0];
+  }
+  reset() {
+    this.m[0] = 1, this.m[1] = 0, this.m[2] = 0, this.m[3] = 1, this.m[4] = 0, this.m[5] = 0;
+  }
+  copy() {
+    return new L(this.m);
+  }
+  copyInto(t) {
+    t.m[0] = this.m[0], t.m[1] = this.m[1], t.m[2] = this.m[2], t.m[3] = this.m[3], t.m[4] = this.m[4], t.m[5] = this.m[5];
+  }
+  point(t) {
+    const e = this.m;
+    return {
+      x: e[0] * t.x + e[2] * t.y + e[4],
+      y: e[1] * t.x + e[3] * t.y + e[5]
+    };
+  }
+  translate(t, e) {
+    return this.m[4] += this.m[0] * t + this.m[2] * e, this.m[5] += this.m[1] * t + this.m[3] * e, this;
+  }
+  scale(t, e) {
+    return this.m[0] *= t, this.m[1] *= t, this.m[2] *= e, this.m[3] *= e, this;
+  }
+  rotate(t) {
+    const e = Math.cos(t), i = Math.sin(t), s = this.m[0] * e + this.m[2] * i, r = this.m[1] * e + this.m[3] * i, a = this.m[0] * -i + this.m[2] * e, o = this.m[1] * -i + this.m[3] * e;
+    return this.m[0] = s, this.m[1] = r, this.m[2] = a, this.m[3] = o, this;
+  }
+  getTranslation() {
+    return {
+      x: this.m[4],
+      y: this.m[5]
+    };
+  }
+  skew(t, e) {
+    const i = this.m[0] + this.m[2] * e, s = this.m[1] + this.m[3] * e, r = this.m[2] + this.m[0] * t, a = this.m[3] + this.m[1] * t;
+    return this.m[0] = i, this.m[1] = s, this.m[2] = r, this.m[3] = a, this;
+  }
+  multiply(t) {
+    const e = this.m[0] * t.m[0] + this.m[2] * t.m[1], i = this.m[1] * t.m[0] + this.m[3] * t.m[1], s = this.m[0] * t.m[2] + this.m[2] * t.m[3], r = this.m[1] * t.m[2] + this.m[3] * t.m[3], a = this.m[0] * t.m[4] + this.m[2] * t.m[5] + this.m[4], o = this.m[1] * t.m[4] + this.m[3] * t.m[5] + this.m[5];
+    return this.m[0] = e, this.m[1] = i, this.m[2] = s, this.m[3] = r, this.m[4] = a, this.m[5] = o, this;
+  }
+  invert() {
+    const t = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]), e = this.m[3] * t, i = -this.m[1] * t, s = -this.m[2] * t, r = this.m[0] * t, a = t * (this.m[2] * this.m[5] - this.m[3] * this.m[4]), o = t * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
+    return this.m[0] = e, this.m[1] = i, this.m[2] = s, this.m[3] = r, this.m[4] = a, this.m[5] = o, this;
+  }
+  getMatrix() {
+    return this.m;
+  }
+  decompose() {
+    const t = this.m[0], e = this.m[1], i = this.m[2], s = this.m[3], r = this.m[4], a = this.m[5], o = t * s - e * i, h = {
+      x: r,
+      y: a,
+      rotation: 0,
+      scaleX: 0,
+      scaleY: 0,
+      skewX: 0,
+      skewY: 0
+    };
+    if (t != 0 || e != 0) {
+      const l = Math.sqrt(t * t + e * e);
+      h.rotation = e > 0 ? Math.acos(t / l) : -Math.acos(t / l), h.scaleX = l, h.scaleY = o / l, h.skewX = (t * i + e * s) / o, h.skewY = 0;
+    } else if (i != 0 || s != 0) {
+      const l = Math.sqrt(i * i + s * s);
+      h.rotation = Math.PI / 2 - (s > 0 ? Math.acos(-i / l) : -Math.acos(i / l)), h.scaleX = o / l, h.scaleY = l, h.skewX = 0, h.skewY = (t * i + e * s) / o;
+    }
+    return h.rotation = c._getRotation(h.rotation), h;
+  }
+}
+const ge = "[object Array]", pe = "[object Number]", me = "[object String]", _e = "[object Boolean]", ye = Math.PI / 180, Ce = 180 / Math.PI, X = "#", ve = "", be = "0", Se = "Konva warning: ", Gt = "Konva error: ", we = "rgb(", pt = {
+  aliceblue: [240, 248, 255],
+  antiquewhite: [250, 235, 215],
+  aqua: [0, 255, 255],
+  aquamarine: [127, 255, 212],
+  azure: [240, 255, 255],
+  beige: [245, 245, 220],
+  bisque: [255, 228, 196],
+  black: [0, 0, 0],
+  blanchedalmond: [255, 235, 205],
+  blue: [0, 0, 255],
+  blueviolet: [138, 43, 226],
+  brown: [165, 42, 42],
+  burlywood: [222, 184, 135],
+  cadetblue: [95, 158, 160],
+  chartreuse: [127, 255, 0],
+  chocolate: [210, 105, 30],
+  coral: [255, 127, 80],
+  cornflowerblue: [100, 149, 237],
+  cornsilk: [255, 248, 220],
+  crimson: [220, 20, 60],
+  cyan: [0, 255, 255],
+  darkblue: [0, 0, 139],
+  darkcyan: [0, 139, 139],
+  darkgoldenrod: [184, 132, 11],
+  darkgray: [169, 169, 169],
+  darkgreen: [0, 100, 0],
+  darkgrey: [169, 169, 169],
+  darkkhaki: [189, 183, 107],
+  darkmagenta: [139, 0, 139],
+  darkolivegreen: [85, 107, 47],
+  darkorange: [255, 140, 0],
+  darkorchid: [153, 50, 204],
+  darkred: [139, 0, 0],
+  darksalmon: [233, 150, 122],
+  darkseagreen: [143, 188, 143],
+  darkslateblue: [72, 61, 139],
+  darkslategray: [47, 79, 79],
+  darkslategrey: [47, 79, 79],
+  darkturquoise: [0, 206, 209],
+  darkviolet: [148, 0, 211],
+  deeppink: [255, 20, 147],
+  deepskyblue: [0, 191, 255],
+  dimgray: [105, 105, 105],
+  dimgrey: [105, 105, 105],
+  dodgerblue: [30, 144, 255],
+  firebrick: [178, 34, 34],
+  floralwhite: [255, 255, 240],
+  forestgreen: [34, 139, 34],
+  fuchsia: [255, 0, 255],
+  gainsboro: [220, 220, 220],
+  ghostwhite: [248, 248, 255],
+  gold: [255, 215, 0],
+  goldenrod: [218, 165, 32],
+  gray: [128, 128, 128],
+  green: [0, 128, 0],
+  greenyellow: [173, 255, 47],
+  grey: [128, 128, 128],
+  honeydew: [240, 255, 240],
+  hotpink: [255, 105, 180],
+  indianred: [205, 92, 92],
+  indigo: [75, 0, 130],
+  ivory: [255, 255, 240],
+  khaki: [240, 230, 140],
+  lavender: [230, 230, 250],
+  lavenderblush: [255, 240, 245],
+  lawngreen: [124, 252, 0],
+  lemonchiffon: [255, 250, 205],
+  lightblue: [173, 216, 230],
+  lightcoral: [240, 128, 128],
+  lightcyan: [224, 255, 255],
+  lightgoldenrodyellow: [250, 250, 210],
+  lightgray: [211, 211, 211],
+  lightgreen: [144, 238, 144],
+  lightgrey: [211, 211, 211],
+  lightpink: [255, 182, 193],
+  lightsalmon: [255, 160, 122],
+  lightseagreen: [32, 178, 170],
+  lightskyblue: [135, 206, 250],
+  lightslategray: [119, 136, 153],
+  lightslategrey: [119, 136, 153],
+  lightsteelblue: [176, 196, 222],
+  lightyellow: [255, 255, 224],
+  lime: [0, 255, 0],
+  limegreen: [50, 205, 50],
+  linen: [250, 240, 230],
+  magenta: [255, 0, 255],
+  maroon: [128, 0, 0],
+  mediumaquamarine: [102, 205, 170],
+  mediumblue: [0, 0, 205],
+  mediumorchid: [186, 85, 211],
+  mediumpurple: [147, 112, 219],
+  mediumseagreen: [60, 179, 113],
+  mediumslateblue: [123, 104, 238],
+  mediumspringgreen: [0, 250, 154],
+  mediumturquoise: [72, 209, 204],
+  mediumvioletred: [199, 21, 133],
+  midnightblue: [25, 25, 112],
+  mintcream: [245, 255, 250],
+  mistyrose: [255, 228, 225],
+  moccasin: [255, 228, 181],
+  navajowhite: [255, 222, 173],
+  navy: [0, 0, 128],
+  oldlace: [253, 245, 230],
+  olive: [128, 128, 0],
+  olivedrab: [107, 142, 35],
+  orange: [255, 165, 0],
+  orangered: [255, 69, 0],
+  orchid: [218, 112, 214],
+  palegoldenrod: [238, 232, 170],
+  palegreen: [152, 251, 152],
+  paleturquoise: [175, 238, 238],
+  palevioletred: [219, 112, 147],
+  papayawhip: [255, 239, 213],
+  peachpuff: [255, 218, 185],
+  peru: [205, 133, 63],
+  pink: [255, 192, 203],
+  plum: [221, 160, 203],
+  powderblue: [176, 224, 230],
+  purple: [128, 0, 128],
+  rebeccapurple: [102, 51, 153],
+  red: [255, 0, 0],
+  rosybrown: [188, 143, 143],
+  royalblue: [65, 105, 225],
+  saddlebrown: [139, 69, 19],
+  salmon: [250, 128, 114],
+  sandybrown: [244, 164, 96],
+  seagreen: [46, 139, 87],
+  seashell: [255, 245, 238],
+  sienna: [160, 82, 45],
+  silver: [192, 192, 192],
+  skyblue: [135, 206, 235],
+  slateblue: [106, 90, 205],
+  slategray: [119, 128, 144],
+  slategrey: [119, 128, 144],
+  snow: [255, 255, 250],
+  springgreen: [0, 255, 127],
+  steelblue: [70, 130, 180],
+  tan: [210, 180, 140],
+  teal: [0, 128, 128],
+  thistle: [216, 191, 216],
+  transparent: [255, 255, 255, 0],
+  tomato: [255, 99, 71],
+  turquoise: [64, 224, 208],
+  violet: [238, 130, 238],
+  wheat: [245, 222, 179],
+  white: [255, 255, 255],
+  whitesmoke: [245, 245, 245],
+  yellow: [255, 255, 0],
+  yellowgreen: [154, 205, 5]
+}, xe = /rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)/;
+let st = [], V = null;
+const Ee = typeof requestAnimationFrame < "u" && requestAnimationFrame || function(n) {
+  setTimeout(n, 16);
+}, c = {
+  _isElement(n) {
+    return !!(n && n.nodeType == 1);
+  },
+  _isFunction(n) {
+    return !!(n && n.constructor && n.call && n.apply);
+  },
+  _isPlainObject(n) {
+    return !!n && n.constructor === Object;
+  },
+  _isArray(n) {
+    return Object.prototype.toString.call(n) === ge;
+  },
+  _isNumber(n) {
+    return Object.prototype.toString.call(n) === pe && !isNaN(n) && isFinite(n);
+  },
+  _isString(n) {
+    return Object.prototype.toString.call(n) === me;
+  },
+  _isBoolean(n) {
+    return Object.prototype.toString.call(n) === _e;
+  },
+  isObject(n) {
+    return n instanceof Object;
+  },
+  isValidSelector(n) {
+    if (typeof n != "string")
+      return !1;
+    const t = n[0];
+    return t === "#" || t === "." || t === t.toUpperCase();
+  },
+  _sign(n) {
+    return n === 0 || n > 0 ? 1 : -1;
+  },
+  requestAnimFrame(n) {
+    st.push(n), st.length === 1 && Ee(function() {
+      const t = st;
+      st = [], t.forEach(function(e) {
+        e();
+      });
+    });
+  },
+  createCanvasElement() {
+    At();
+    const n = document.createElement("canvas");
+    try {
+      n.style = n.style || {};
+    } catch {
+    }
+    return n;
+  },
+  createImageElement() {
+    return At(), document.createElement("img");
+  },
+  _isInDocument(n) {
+    for (; n = n.parentNode; )
+      if (n == document)
+        return !0;
+    return !1;
+  },
+  _urlToImage(n, t) {
+    const e = c.createImageElement();
+    e.onload = function() {
+      t(e);
+    }, e.src = n;
+  },
+  _rgbToHex(n, t, e) {
+    return ((1 << 24) + (n << 16) + (t << 8) + e).toString(16).slice(1);
+  },
+  _hexToRgb(n) {
+    n = n.replace(X, ve);
+    const t = parseInt(n, 16);
+    return {
+      r: t >> 16 & 255,
+      g: t >> 8 & 255,
+      b: t & 255
+    };
+  },
+  getRandomColor() {
+    let n = (Math.random() * 16777215 << 0).toString(16);
+    for (; n.length < 6; )
+      n = be + n;
+    return X + n;
+  },
+  isCanvasFarblingActive() {
+    if (V !== null)
+      return V;
+    if (typeof document > "u")
+      return V = !1, !1;
+    const n = this.createCanvasElement();
+    n.width = 10, n.height = 10;
+    const t = n.getContext("2d", {
+      willReadFrequently: !0
+    });
+    t.clearRect(0, 0, 10, 10), t.fillStyle = "#282828", t.fillRect(0, 0, 10, 10);
+    const e = t.getImageData(0, 0, 10, 10).data;
+    let i = !1;
+    for (let s = 0; s < 100; s++)
+      if (e[s * 4] !== 40 || e[s * 4 + 1] !== 40 || e[s * 4 + 2] !== 40 || e[s * 4 + 3] !== 255) {
+        i = !0;
+        break;
+      }
+    return V = i, this.releaseCanvas(n), V;
+  },
+  getHitColor() {
+    const n = this.getRandomColor();
+    return this.isCanvasFarblingActive() ? this.getSnappedHexColor(n) : n;
+  },
+  getHitColorKey(n, t, e) {
+    return this.isCanvasFarblingActive() && (n = Math.round(n / 5) * 5, t = Math.round(t / 5) * 5, e = Math.round(e / 5) * 5), X + this._rgbToHex(n, t, e);
+  },
+  getSnappedHexColor(n) {
+    const t = this._hexToRgb(n);
+    return X + this._rgbToHex(Math.round(t.r / 5) * 5, Math.round(t.g / 5) * 5, Math.round(t.b / 5) * 5);
+  },
+  getRGB(n) {
+    let t;
+    return n in pt ? (t = pt[n], {
+      r: t[0],
+      g: t[1],
+      b: t[2]
+    }) : n[0] === X ? this._hexToRgb(n.substring(1)) : n.substr(0, 4) === we ? (t = xe.exec(n.replace(/ /g, "")), {
+      r: parseInt(t[1], 10),
+      g: parseInt(t[2], 10),
+      b: parseInt(t[3], 10)
+    }) : {
+      r: 0,
+      g: 0,
+      b: 0
+    };
+  },
+  colorToRGBA(n) {
+    return n = n || "black", c._namedColorToRBA(n) || c._hex3ColorToRGBA(n) || c._hex4ColorToRGBA(n) || c._hex6ColorToRGBA(n) || c._hex8ColorToRGBA(n) || c._rgbColorToRGBA(n) || c._rgbaColorToRGBA(n) || c._hslColorToRGBA(n);
+  },
+  _namedColorToRBA(n) {
+    const t = pt[n.toLowerCase()];
+    return t ? {
+      r: t[0],
+      g: t[1],
+      b: t[2],
+      a: 1
+    } : null;
+  },
+  _rgbColorToRGBA(n) {
+    if (n.indexOf("rgb(") === 0) {
+      n = n.match(/rgb\(([^)]+)\)/)[1];
+      const t = n.split(/ *, */).map(Number);
+      return {
+        r: t[0],
+        g: t[1],
+        b: t[2],
+        a: 1
+      };
+    }
+  },
+  _rgbaColorToRGBA(n) {
+    if (n.indexOf("rgba(") === 0) {
+      n = n.match(/rgba\(([^)]+)\)/)[1];
+      const t = n.split(/ *, */).map((e, i) => e.slice(-1) === "%" ? i === 3 ? parseInt(e) / 100 : parseInt(e) / 100 * 255 : Number(e));
+      return {
+        r: t[0],
+        g: t[1],
+        b: t[2],
+        a: t[3]
+      };
+    }
+  },
+  _hex8ColorToRGBA(n) {
+    if (n[0] === "#" && n.length === 9)
+      return {
+        r: parseInt(n.slice(1, 3), 16),
+        g: parseInt(n.slice(3, 5), 16),
+        b: parseInt(n.slice(5, 7), 16),
+        a: parseInt(n.slice(7, 9), 16) / 255
+      };
+  },
+  _hex6ColorToRGBA(n) {
+    if (n[0] === "#" && n.length === 7)
+      return {
+        r: parseInt(n.slice(1, 3), 16),
+        g: parseInt(n.slice(3, 5), 16),
+        b: parseInt(n.slice(5, 7), 16),
+        a: 1
+      };
+  },
+  _hex4ColorToRGBA(n) {
+    if (n[0] === "#" && n.length === 5)
+      return {
+        r: parseInt(n[1] + n[1], 16),
+        g: parseInt(n[2] + n[2], 16),
+        b: parseInt(n[3] + n[3], 16),
+        a: parseInt(n[4] + n[4], 16) / 255
+      };
+  },
+  _hex3ColorToRGBA(n) {
+    if (n[0] === "#" && n.length === 4)
+      return {
+        r: parseInt(n[1] + n[1], 16),
+        g: parseInt(n[2] + n[2], 16),
+        b: parseInt(n[3] + n[3], 16),
+        a: 1
+      };
+  },
+  _hslColorToRGBA(n) {
+    if (/hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.test(n)) {
+      const [t, ...e] = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(n), i = Number(e[0]) / 360, s = Number(e[1]) / 100, r = Number(e[2]) / 100;
+      let a, o, h;
+      if (s === 0)
+        return h = r * 255, {
+          r: Math.round(h),
+          g: Math.round(h),
+          b: Math.round(h),
+          a: 1
+        };
+      r < 0.5 ? a = r * (1 + s) : a = r + s - r * s;
+      const l = 2 * r - a, d = [0, 0, 0];
+      for (let u = 0; u < 3; u++)
+        o = i + 1 / 3 * -(u - 1), o < 0 && o++, o > 1 && o--, 6 * o < 1 ? h = l + (a - l) * 6 * o : 2 * o < 1 ? h = a : 3 * o < 2 ? h = l + (a - l) * (2 / 3 - o) * 6 : h = l, d[u] = h * 255;
+      return {
+        r: Math.round(d[0]),
+        g: Math.round(d[1]),
+        b: Math.round(d[2]),
+        a: 1
+      };
+    }
+  },
+  haveIntersection(n, t) {
+    return !(t.x > n.x + n.width || t.x + t.width < n.x || t.y > n.y + n.height || t.y + t.height < n.y);
+  },
+  cloneObject(n) {
+    const t = {};
+    for (const e in n)
+      this._isPlainObject(n[e]) ? t[e] = this.cloneObject(n[e]) : this._isArray(n[e]) ? t[e] = this.cloneArray(n[e]) : t[e] = n[e];
+    return t;
+  },
+  cloneArray(n) {
+    return n.slice(0);
+  },
+  degToRad(n) {
+    return n * ye;
+  },
+  radToDeg(n) {
+    return n * Ce;
+  },
+  _degToRad(n) {
+    return c.warn("Util._degToRad is removed. Please use public Util.degToRad instead."), c.degToRad(n);
+  },
+  _radToDeg(n) {
+    return c.warn("Util._radToDeg is removed. Please use public Util.radToDeg instead."), c.radToDeg(n);
+  },
+  _getRotation(n) {
+    return m.angleDeg ? c.radToDeg(n) : n;
+  },
+  _capitalize(n) {
+    return n.charAt(0).toUpperCase() + n.slice(1);
+  },
+  throw(n) {
+    throw new Error(Gt + n);
+  },
+  error(n) {
+    console.error(Gt + n);
+  },
+  warn(n) {
+    m.showWarnings && console.warn(Se + n);
+  },
+  each(n, t) {
+    for (const e in n)
+      t(e, n[e]);
+  },
+  _inRange(n, t, e) {
+    return t <= n && n < e;
+  },
+  _getProjectionToSegment(n, t, e, i, s, r) {
+    let a, o, h;
+    const l = (n - e) * (n - e) + (t - i) * (t - i);
+    if (l == 0)
+      a = n, o = t, h = (s - e) * (s - e) + (r - i) * (r - i);
+    else {
+      const d = ((s - n) * (e - n) + (r - t) * (i - t)) / l;
+      d < 0 ? (a = n, o = t, h = (n - s) * (n - s) + (t - r) * (t - r)) : d > 1 ? (a = e, o = i, h = (e - s) * (e - s) + (i - r) * (i - r)) : (a = n + d * (e - n), o = t + d * (i - t), h = (a - s) * (a - s) + (o - r) * (o - r));
+    }
+    return [a, o, h];
+  },
+  _getProjectionToLine(n, t, e) {
+    const i = c.cloneObject(n);
+    let s = Number.MAX_VALUE;
+    return t.forEach(function(r, a) {
+      if (!e && a === t.length - 1)
+        return;
+      const o = t[(a + 1) % t.length], h = c._getProjectionToSegment(r.x, r.y, o.x, o.y, n.x, n.y), l = h[0], d = h[1], u = h[2];
+      u < s && (i.x = l, i.y = d, s = u);
+    }), i;
+  },
+  _prepareArrayForTween(n, t, e) {
+    const i = [], s = [];
+    if (n.length > t.length) {
+      const a = t;
+      t = n, n = a;
+    }
+    for (let a = 0; a < n.length; a += 2)
+      i.push({
+        x: n[a],
+        y: n[a + 1]
+      });
+    for (let a = 0; a < t.length; a += 2)
+      s.push({
+        x: t[a],
+        y: t[a + 1]
+      });
+    const r = [];
+    return s.forEach(function(a) {
+      const o = c._getProjectionToLine(a, i, e);
+      r.push(o.x), r.push(o.y);
+    }), r;
+  },
+  _prepareToStringify(n) {
+    let t;
+    n.visitedByCircularReferenceRemoval = !0;
+    for (const e in n)
+      if (n.hasOwnProperty(e) && n[e] && typeof n[e] == "object") {
+        if (t = Object.getOwnPropertyDescriptor(n, e), n[e].visitedByCircularReferenceRemoval || c._isElement(n[e]))
+          if (t.configurable)
+            delete n[e];
+          else
+            return null;
+        else if (c._prepareToStringify(n[e]) === null)
+          if (t.configurable)
+            delete n[e];
+          else
+            return null;
+      }
+    return delete n.visitedByCircularReferenceRemoval, n;
+  },
+  _assign(n, t) {
+    for (const e in t)
+      n[e] = t[e];
+    return n;
+  },
+  _getFirstPointerId(n) {
+    return n.touches ? n.changedTouches[0].identifier : n.pointerId || 999;
+  },
+  releaseCanvas(...n) {
+    m.releaseCanvasOnDestroy && n.forEach((t) => {
+      t.width = 0, t.height = 0;
+    });
+  },
+  drawRoundedRectPath(n, t, e, i) {
+    let s = t < 0 ? t : 0, r = e < 0 ? e : 0;
+    t = Math.abs(t), e = Math.abs(e);
+    let a = 0, o = 0, h = 0, l = 0;
+    typeof i == "number" ? a = o = h = l = Math.min(i, t / 2, e / 2) : (a = Math.min(i[0] || 0, t / 2, e / 2), o = Math.min(i[1] || 0, t / 2, e / 2), l = Math.min(i[2] || 0, t / 2, e / 2), h = Math.min(i[3] || 0, t / 2, e / 2)), n.moveTo(s + a, r), n.lineTo(s + t - o, r), n.arc(s + t - o, r + o, o, Math.PI * 3 / 2, 0, !1), n.lineTo(s + t, r + e - l), n.arc(s + t - l, r + e - l, l, 0, Math.PI / 2, !1), n.lineTo(s + h, r + e), n.arc(s + h, r + e - h, h, Math.PI / 2, Math.PI, !1), n.lineTo(s, r + a), n.arc(s + a, r + a, a, Math.PI, Math.PI * 3 / 2, !1);
+  },
+  drawRoundedPolygonPath(n, t, e, i, s) {
+    i = Math.abs(i);
+    for (let r = 0; r < e; r++) {
+      const a = t[(r - 1 + e) % e], o = t[r], h = t[(r + 1) % e], l = { x: o.x - a.x, y: o.y - a.y }, d = { x: h.x - o.x, y: h.y - o.y }, u = Math.hypot(l.x, l.y), f = Math.hypot(d.x, d.y);
+      let C;
+      typeof s == "number" ? C = s : C = r < s.length ? s[r] : 0, C = i * Math.cos(Math.PI / e) * Math.min(1, C / i * 2);
+      const P = { x: l.x / u, y: l.y / u }, E = { x: d.x / f, y: d.y / f }, x = {
+        x: o.x - P.x * C,
+        y: o.y - P.y * C
+      }, A = {
+        x: o.x + E.x * C,
+        y: o.y + E.y * C
+      };
+      r === 0 ? n.moveTo(x.x, x.y) : n.lineTo(x.x, x.y), n.arcTo(o.x, o.y, A.x, A.y, C);
+    }
+  }
+};
+function Pe(n) {
+  const t = [], e = n.length, i = c;
+  for (let s = 0; s < e; s++) {
+    let r = n[s];
+    i._isNumber(r) ? r = Math.round(r * 1e3) / 1e3 : i._isString(r) || (r = r + ""), t.push(r);
+  }
+  return t;
+}
+const Ot = ",", ke = "(", Re = ")", Te = "([", Ae = "])", Ge = ";", Oe = "()", De = "=", Dt = [
+  "arc",
+  "arcTo",
+  "beginPath",
+  "bezierCurveTo",
+  "clearRect",
+  "clip",
+  "closePath",
+  "createLinearGradient",
+  "createPattern",
+  "createRadialGradient",
+  "drawImage",
+  "ellipse",
+  "fill",
+  "fillText",
+  "getImageData",
+  "createImageData",
+  "lineTo",
+  "moveTo",
+  "putImageData",
+  "quadraticCurveTo",
+  "rect",
+  "roundRect",
+  "restore",
+  "rotate",
+  "save",
+  "scale",
+  "setLineDash",
+  "setTransform",
+  "stroke",
+  "strokeText",
+  "transform",
+  "translate"
+], Le = [
+  "fillStyle",
+  "strokeStyle",
+  "shadowColor",
+  "shadowBlur",
+  "shadowOffsetX",
+  "shadowOffsetY",
+  "letterSpacing",
+  "lineCap",
+  "lineDashOffset",
+  "lineJoin",
+  "lineWidth",
+  "miterLimit",
+  "direction",
+  "font",
+  "textAlign",
+  "textBaseline",
+  "globalAlpha",
+  "globalCompositeOperation",
+  "imageSmoothingEnabled",
+  "filter"
+], Ie = 100;
+let rt = null;
+function Lt() {
+  if (rt !== null)
+    return rt;
+  try {
+    const t = c.createCanvasElement().getContext("2d");
+    return t ? !!t && "filter" in t : (rt = !1, !1);
+  } catch {
+    return rt = !1, !1;
+  }
+}
+class ft {
+  constructor(t) {
+    this.canvas = t, m.enableTrace && (this.traceArr = [], this._enableTrace());
+  }
+  fillShape(t) {
+    t.fillEnabled() && this._fill(t);
+  }
+  _fill(t) {
+  }
+  strokeShape(t) {
+    t.hasStroke() && this._stroke(t);
+  }
+  _stroke(t) {
+  }
+  fillStrokeShape(t) {
+    t.attrs.fillAfterStrokeEnabled ? (this.strokeShape(t), this.fillShape(t)) : (this.fillShape(t), this.strokeShape(t));
+  }
+  getTrace(t, e) {
+    let i = this.traceArr, s = i.length, r = "", a, o, h, l;
+    for (a = 0; a < s; a++)
+      o = i[a], h = o.method, h ? (l = o.args, r += h, t ? r += Oe : c._isArray(l[0]) ? r += Te + l.join(Ot) + Ae : (e && (l = l.map((d) => typeof d == "number" ? Math.floor(d) : d)), r += ke + l.join(Ot) + Re)) : (r += o.property, t || (r += De + o.val)), r += Ge;
+    return r;
+  }
+  clearTrace() {
+    this.traceArr = [];
+  }
+  _trace(t) {
+    let e = this.traceArr, i;
+    e.push(t), i = e.length, i >= Ie && e.shift();
+  }
+  reset() {
+    const t = this.getCanvas().getPixelRatio();
+    this.setTransform(1 * t, 0, 0, 1 * t, 0, 0);
+  }
+  getCanvas() {
+    return this.canvas;
+  }
+  clear(t) {
+    const e = this.getCanvas();
+    t ? this.clearRect(t.x || 0, t.y || 0, t.width || 0, t.height || 0) : this.clearRect(0, 0, e.getWidth() / e.pixelRatio, e.getHeight() / e.pixelRatio);
+  }
+  _applyLineCap(t) {
+    const e = t.attrs.lineCap;
+    e && this.setAttr("lineCap", e);
+  }
+  _applyOpacity(t) {
+    const e = t.getAbsoluteOpacity();
+    e !== 1 && this.setAttr("globalAlpha", e);
+  }
+  _applyLineJoin(t) {
+    const e = t.attrs.lineJoin;
+    e && this.setAttr("lineJoin", e);
+  }
+  _applyMiterLimit(t) {
+    const e = t.attrs.miterLimit;
+    e != null && this.setAttr("miterLimit", e);
+  }
+  setAttr(t, e) {
+    this._context[t] = e;
+  }
+  arc(t, e, i, s, r, a) {
+    this._context.arc(t, e, i, s, r, a);
+  }
+  arcTo(t, e, i, s, r) {
+    this._context.arcTo(t, e, i, s, r);
+  }
+  beginPath() {
+    this._context.beginPath();
+  }
+  bezierCurveTo(t, e, i, s, r, a) {
+    this._context.bezierCurveTo(t, e, i, s, r, a);
+  }
+  clearRect(t, e, i, s) {
+    this._context.clearRect(t, e, i, s);
+  }
+  clip(...t) {
+    this._context.clip.apply(this._context, t);
+  }
+  closePath() {
+    this._context.closePath();
+  }
+  createImageData(t, e) {
+    const i = arguments;
+    if (i.length === 2)
+      return this._context.createImageData(t, e);
+    if (i.length === 1)
+      return this._context.createImageData(t);
+  }
+  createLinearGradient(t, e, i, s) {
+    return this._context.createLinearGradient(t, e, i, s);
+  }
+  createPattern(t, e) {
+    return this._context.createPattern(t, e);
+  }
+  createRadialGradient(t, e, i, s, r, a) {
+    return this._context.createRadialGradient(t, e, i, s, r, a);
+  }
+  drawImage(t, e, i, s, r, a, o, h, l) {
+    const d = arguments, u = this._context;
+    d.length === 3 ? u.drawImage(t, e, i) : d.length === 5 ? u.drawImage(t, e, i, s, r) : d.length === 9 && u.drawImage(t, e, i, s, r, a, o, h, l);
+  }
+  ellipse(t, e, i, s, r, a, o, h) {
+    this._context.ellipse(t, e, i, s, r, a, o, h);
+  }
+  isPointInPath(t, e, i, s) {
+    return i ? this._context.isPointInPath(i, t, e, s) : this._context.isPointInPath(t, e, s);
+  }
+  fill(...t) {
+    this._context.fill.apply(this._context, t);
+  }
+  fillRect(t, e, i, s) {
+    this._context.fillRect(t, e, i, s);
+  }
+  strokeRect(t, e, i, s) {
+    this._context.strokeRect(t, e, i, s);
+  }
+  fillText(t, e, i, s) {
+    s ? this._context.fillText(t, e, i, s) : this._context.fillText(t, e, i);
+  }
+  measureText(t) {
+    return this._context.measureText(t);
+  }
+  getImageData(t, e, i, s) {
+    return this._context.getImageData(t, e, i, s);
+  }
+  lineTo(t, e) {
+    this._context.lineTo(t, e);
+  }
+  moveTo(t, e) {
+    this._context.moveTo(t, e);
+  }
+  rect(t, e, i, s) {
+    this._context.rect(t, e, i, s);
+  }
+  roundRect(t, e, i, s, r) {
+    this._context.roundRect(t, e, i, s, r);
+  }
+  putImageData(t, e, i) {
+    this._context.putImageData(t, e, i);
+  }
+  quadraticCurveTo(t, e, i, s) {
+    this._context.quadraticCurveTo(t, e, i, s);
+  }
+  restore() {
+    this._context.restore();
+  }
+  rotate(t) {
+    this._context.rotate(t);
+  }
+  save() {
+    this._context.save();
+  }
+  scale(t, e) {
+    this._context.scale(t, e);
+  }
+  setLineDash(t) {
+    this._context.setLineDash ? this._context.setLineDash(t) : "mozDash" in this._context ? this._context.mozDash = t : "webkitLineDash" in this._context && (this._context.webkitLineDash = t);
+  }
+  getLineDash() {
+    return this._context.getLineDash();
+  }
+  setTransform(t, e, i, s, r, a) {
+    this._context.setTransform(t, e, i, s, r, a);
+  }
+  stroke(t) {
+    t ? this._context.stroke(t) : this._context.stroke();
+  }
+  strokeText(t, e, i, s) {
+    this._context.strokeText(t, e, i, s);
+  }
+  transform(t, e, i, s, r, a) {
+    this._context.transform(t, e, i, s, r, a);
+  }
+  translate(t, e) {
+    this._context.translate(t, e);
+  }
+  _enableTrace() {
+    let t = this, e = Dt.length, i = this.setAttr, s, r;
+    const a = function(o) {
+      let h = t[o], l;
+      t[o] = function() {
+        return r = Pe(Array.prototype.slice.call(arguments, 0)), l = h.apply(t, arguments), t._trace({
+          method: o,
+          args: r
+        }), l;
+      };
+    };
+    for (s = 0; s < e; s++)
+      a(Dt[s]);
+    t.setAttr = function() {
+      i.apply(t, arguments);
+      const o = arguments[0];
+      let h = arguments[1];
+      (o === "shadowOffsetX" || o === "shadowOffsetY" || o === "shadowBlur") && (h = h / this.canvas.getPixelRatio()), t._trace({
+        property: o,
+        val: h
+      });
+    };
+  }
+  _applyGlobalCompositeOperation(t) {
+    const e = t.attrs.globalCompositeOperation;
+    !e || e === "source-over" || this.setAttr("globalCompositeOperation", e);
+  }
+}
+Le.forEach(function(n) {
+  Object.defineProperty(ft.prototype, n, {
+    get() {
+      return this._context[n];
+    },
+    set(t) {
+      this._context[n] = t;
+    }
+  });
+});
+class Me extends ft {
+  constructor(t, { willReadFrequently: e = !1 } = {}) {
+    super(t), this._context = t._canvas.getContext("2d", {
+      willReadFrequently: e
+    });
+  }
+  _fillColor(t) {
+    const e = t.fill();
+    this.setAttr("fillStyle", e), t._fillFunc(this);
+  }
+  _fillPattern(t) {
+    this.setAttr("fillStyle", t._getFillPattern()), t._fillFunc(this);
+  }
+  _fillLinearGradient(t) {
+    const e = t._getLinearGradient();
+    e && (this.setAttr("fillStyle", e), t._fillFunc(this));
+  }
+  _fillRadialGradient(t) {
+    const e = t._getRadialGradient();
+    e && (this.setAttr("fillStyle", e), t._fillFunc(this));
+  }
+  _fill(t) {
+    const e = t.fill(), i = t.getFillPriority();
+    if (e && i === "color") {
+      this._fillColor(t);
+      return;
+    }
+    const s = t.getFillPatternImage();
+    if (s && i === "pattern") {
+      this._fillPattern(t);
+      return;
+    }
+    const r = t.getFillLinearGradientColorStops();
+    if (r && i === "linear-gradient") {
+      this._fillLinearGradient(t);
+      return;
+    }
+    const a = t.getFillRadialGradientColorStops();
+    if (a && i === "radial-gradient") {
+      this._fillRadialGradient(t);
+      return;
+    }
+    e ? this._fillColor(t) : s ? this._fillPattern(t) : r ? this._fillLinearGradient(t) : a && this._fillRadialGradient(t);
+  }
+  _strokeLinearGradient(t) {
+    const e = t.getStrokeLinearGradientStartPoint(), i = t.getStrokeLinearGradientEndPoint(), s = t.getStrokeLinearGradientColorStops(), r = this.createLinearGradient(e.x, e.y, i.x, i.y);
+    if (s) {
+      for (let a = 0; a < s.length; a += 2)
+        r.addColorStop(s[a], s[a + 1]);
+      this.setAttr("strokeStyle", r);
+    }
+  }
+  _stroke(t) {
+    const e = t.dash(), i = t.getStrokeScaleEnabled();
+    if (t.hasStroke()) {
+      if (!i) {
+        this.save();
+        const r = this.getCanvas().getPixelRatio();
+        this.setTransform(r, 0, 0, r, 0, 0);
+      }
+      this._applyLineCap(t), e && t.dashEnabled() && (this.setLineDash(e), this.setAttr("lineDashOffset", t.dashOffset())), this.setAttr("lineWidth", t.strokeWidth()), t.getShadowForStrokeEnabled() || this.setAttr("shadowColor", "rgba(0,0,0,0)"), t.getStrokeLinearGradientColorStops() ? this._strokeLinearGradient(t) : this.setAttr("strokeStyle", t.stroke()), t._strokeFunc(this), i || this.restore();
+    }
+  }
+  _applyShadow(t) {
+    var e, i, s;
+    const r = (e = t.getShadowRGBA()) !== null && e !== void 0 ? e : "black", a = (i = t.getShadowBlur()) !== null && i !== void 0 ? i : 5, o = (s = t.getShadowOffset()) !== null && s !== void 0 ? s : {
+      x: 0,
+      y: 0
+    }, h = t.getAbsoluteScale(), l = this.canvas.getPixelRatio(), d = h.x * l, u = h.y * l;
+    this.setAttr("shadowColor", r), this.setAttr("shadowBlur", a * Math.min(Math.abs(d), Math.abs(u))), this.setAttr("shadowOffsetX", o.x * d), this.setAttr("shadowOffsetY", o.y * u);
+  }
+}
+class Fe extends ft {
+  constructor(t) {
+    super(t), this._context = t._canvas.getContext("2d", {
+      willReadFrequently: !0
+    });
+  }
+  _fill(t) {
+    this.save(), this.setAttr("fillStyle", t.colorKey), t._fillFuncHit(this), this.restore();
+  }
+  strokeShape(t) {
+    t.hasHitStroke() && this._stroke(t);
+  }
+  _stroke(t) {
+    if (t.hasHitStroke()) {
+      const e = t.getStrokeScaleEnabled();
+      if (!e) {
+        this.save();
+        const r = this.getCanvas().getPixelRatio();
+        this.setTransform(r, 0, 0, r, 0, 0);
+      }
+      this._applyLineCap(t);
+      const i = t.hitStrokeWidth(), s = i === "auto" ? t.strokeWidth() : i;
+      this.setAttr("lineWidth", s), this.setAttr("strokeStyle", t.colorKey), t._strokeFuncHit(this), e || this.restore();
+    }
+  }
+}
+let at;
+function Be() {
+  if (at)
+    return at;
+  const n = c.createCanvasElement(), t = n.getContext("2d");
+  return at = (function() {
+    const e = m._global.devicePixelRatio || 1, i = t.webkitBackingStorePixelRatio || t.mozBackingStorePixelRatio || t.msBackingStorePixelRatio || t.oBackingStorePixelRatio || t.backingStorePixelRatio || 1;
+    return e / i;
+  })(), c.releaseCanvas(n), at;
+}
+class xt {
+  constructor(t) {
+    this.pixelRatio = 1, this.width = 0, this.height = 0, this.isCache = !1;
+    const i = (t || {}).pixelRatio || m.pixelRatio || Be();
+    this.pixelRatio = i, this._canvas = c.createCanvasElement(), this._canvas.style.padding = "0", this._canvas.style.margin = "0", this._canvas.style.border = "0", this._canvas.style.background = "transparent", this._canvas.style.position = "absolute", this._canvas.style.top = "0", this._canvas.style.left = "0";
+  }
+  getContext() {
+    return this.context;
+  }
+  getPixelRatio() {
+    return this.pixelRatio;
+  }
+  setPixelRatio(t) {
+    const e = this.pixelRatio;
+    this.pixelRatio = t, this.setSize(this.getWidth() / e, this.getHeight() / e);
+  }
+  setWidth(t) {
+    this.width = this._canvas.width = t * this.pixelRatio, this._canvas.style.width = t + "px";
+    const e = this.pixelRatio;
+    this.getContext()._context.scale(e, e);
+  }
+  setHeight(t) {
+    this.height = this._canvas.height = t * this.pixelRatio, this._canvas.style.height = t + "px";
+    const e = this.pixelRatio;
+    this.getContext()._context.scale(e, e);
+  }
+  getWidth() {
+    return this.width;
+  }
+  getHeight() {
+    return this.height;
+  }
+  setSize(t, e) {
+    this.setWidth(t || 0), this.setHeight(e || 0);
+  }
+  toDataURL(t, e) {
+    try {
+      return this._canvas.toDataURL(t, e);
+    } catch {
+      try {
+        return this._canvas.toDataURL();
+      } catch (s) {
+        return c.error("Unable to get data URL. " + s.message + " For more info read https://konvajs.org/docs/posts/Tainted_Canvas.html."), "";
+      }
+    }
+  }
+}
+class D extends xt {
+  constructor(t = { width: 0, height: 0, willReadFrequently: !1 }) {
+    super(t), this.context = new Me(this, {
+      willReadFrequently: t.willReadFrequently
+    }), this.setSize(t.width, t.height);
+  }
+}
+class Et extends xt {
+  constructor(t = { width: 0, height: 0 }) {
+    super(t), this.hitCanvas = !0, this.context = new Fe(this), this.setSize(t.width, t.height);
+  }
+}
+const v = {
+  get isDragging() {
+    let n = !1;
+    return v._dragElements.forEach((t) => {
+      t.dragStatus === "dragging" && (n = !0);
+    }), n;
+  },
+  justDragged: !1,
+  get node() {
+    let n;
+    return v._dragElements.forEach((t) => {
+      n = t.node;
+    }), n;
+  },
+  _dragElements: /* @__PURE__ */ new Map(),
+  _drag(n) {
+    const t = [];
+    v._dragElements.forEach((e, i) => {
+      const { node: s } = e, r = s.getStage();
+      r.setPointersPositions(n), e.pointerId === void 0 && (e.pointerId = c._getFirstPointerId(n));
+      const a = r._changedPointerPositions.find((o) => o.id === e.pointerId);
+      if (a) {
+        if (e.dragStatus !== "dragging") {
+          const o = s.dragDistance();
+          if (Math.max(Math.abs(a.x - e.startPointerPos.x), Math.abs(a.y - e.startPointerPos.y)) < o || (s.startDrag({ evt: n }), !s.isDragging()))
+            return;
+        }
+        s._setDragPosition(n, e), t.push(s);
+      }
+    }), t.forEach((e) => {
+      e.getStage() && e.fire("dragmove", {
+        type: "dragmove",
+        target: e,
+        evt: n
+      }, !0);
+    });
+  },
+  _endDragBefore(n) {
+    const t = [];
+    v._dragElements.forEach((e) => {
+      const { node: i } = e, s = i.getStage();
+      if (n && s.setPointersPositions(n), !s._changedPointerPositions.find((o) => o.id === e.pointerId))
+        return;
+      (e.dragStatus === "dragging" || e.dragStatus === "stopped") && (v.justDragged = !0, m._mouseListenClick = !1, m._touchListenClick = !1, m._pointerListenClick = !1, e.dragStatus = "stopped");
+      const a = e.node.getLayer() || e.node instanceof m.Stage && e.node;
+      a && t.indexOf(a) === -1 && t.push(a);
+    }), t.forEach((e) => {
+      e.draw();
+    });
+  },
+  _endDragAfter(n) {
+    v._dragElements.forEach((t, e) => {
+      t.dragStatus === "stopped" && t.node.fire("dragend", {
+        type: "dragend",
+        target: t.node,
+        evt: n
+      }, !0), t.dragStatus !== "dragging" && v._dragElements.delete(e);
+    });
+  }
+};
+m.isBrowser && (window.addEventListener("mouseup", v._endDragBefore, !0), window.addEventListener("touchend", v._endDragBefore, !0), window.addEventListener("touchcancel", v._endDragBefore, !0), window.addEventListener("mousemove", v._drag), window.addEventListener("touchmove", v._drag), window.addEventListener("mouseup", v._endDragAfter, !1), window.addEventListener("touchend", v._endDragAfter, !1), window.addEventListener("touchcancel", v._endDragAfter, !1));
+function I(n) {
+  return c._isString(n) ? '"' + n + '"' : Object.prototype.toString.call(n) === "[object Number]" || c._isBoolean(n) ? n : Object.prototype.toString.call(n);
+}
+function wi(n) {
+  return n > 255 ? 255 : n < 0 ? 0 : Math.round(n);
+}
+function b() {
+  if (m.isUnminified)
+    return function(n, t) {
+      return c._isNumber(n) || c.warn(I(n) + ' is a not valid value for "' + t + '" attribute. The value should be a number.'), n;
+    };
+}
+function xi(n) {
+  if (m.isUnminified)
+    return function(t, e) {
+      let i = c._isNumber(t), s = c._isArray(t) && t.length == n;
+      return !i && !s && c.warn(I(t) + ' is a not valid value for "' + e + '" attribute. The value should be a number or Array<number>(' + n + ")"), t;
+    };
+}
+function Ne() {
+  if (m.isUnminified)
+    return function(n, t) {
+      return c._isNumber(n) || n === "auto" || c.warn(I(n) + ' is a not valid value for "' + t + '" attribute. The value should be a number or "auto".'), n;
+    };
+}
+function Y() {
+  if (m.isUnminified)
+    return function(n, t) {
+      return c._isString(n) || c.warn(I(n) + ' is a not valid value for "' + t + '" attribute. The value should be a string.'), n;
+    };
+}
+function Wt() {
+  if (m.isUnminified)
+    return function(n, t) {
+      const e = c._isString(n), i = Object.prototype.toString.call(n) === "[object CanvasGradient]" || n && n.addColorStop;
+      return e || i || c.warn(I(n) + ' is a not valid value for "' + t + '" attribute. The value should be a string or a native gradient.'), n;
+    };
+}
+function Ei() {
+  if (m.isUnminified)
+    return function(n, t) {
+      const e = Int8Array ? Object.getPrototypeOf(Int8Array) : null;
+      return e && n instanceof e || (c._isArray(n) ? n.forEach(function(i) {
+        c._isNumber(i) || c.warn('"' + t + '" attribute has non numeric element ' + i + ". Make sure that all elements are numbers.");
+      }) : c.warn(I(n) + ' is a not valid value for "' + t + '" attribute. The value should be a array of numbers.')), n;
+    };
+}
+function M() {
+  if (m.isUnminified)
+    return function(n, t) {
+      return n === !0 || n === !1 || c.warn(I(n) + ' is a not valid value for "' + t + '" attribute. The value should be a boolean.'), n;
+    };
+}
+function He(n) {
+  if (m.isUnminified)
+    return function(t, e) {
+      return t == null || c.isObject(t) || c.warn(I(t) + ' is a not valid value for "' + e + '" attribute. The value should be an object with properties ' + n), t;
+    };
+}
+const W = "get", j = "set", g = {
+  addGetterSetter(n, t, e, i, s) {
+    g.addGetter(n, t, e), g.addSetter(n, t, i, s), g.addOverloadedGetterSetter(n, t);
+  },
+  addGetter(n, t, e) {
+    const i = W + c._capitalize(t);
+    n.prototype[i] = n.prototype[i] || function() {
+      const s = this.attrs[t];
+      return s === void 0 ? e : s;
+    };
+  },
+  addSetter(n, t, e, i) {
+    const s = j + c._capitalize(t);
+    n.prototype[s] || g.overWriteSetter(n, t, e, i);
+  },
+  overWriteSetter(n, t, e, i) {
+    const s = j + c._capitalize(t);
+    n.prototype[s] = function(r) {
+      return e && r !== void 0 && r !== null && (r = e.call(this, r, t)), this._setAttr(t, r), i && i.call(this), this;
+    };
+  },
+  addComponentsGetterSetter(n, t, e, i, s) {
+    const r = e.length, a = c._capitalize, o = W + a(t), h = j + a(t);
+    n.prototype[o] = function() {
+      const d = {};
+      for (let u = 0; u < r; u++) {
+        const f = e[u];
+        d[f] = this.getAttr(t + a(f));
+      }
+      return d;
+    };
+    const l = He(e);
+    n.prototype[h] = function(d) {
+      const u = this.attrs[t];
+      i && (d = i.call(this, d, t)), l && l.call(this, d, t);
+      for (const f in d)
+        d.hasOwnProperty(f) && this._setAttr(t + a(f), d[f]);
+      return d || e.forEach((f) => {
+        this._setAttr(t + a(f), void 0);
+      }), this._fireChangeEvent(t, u, d), s && s.call(this), this;
+    }, g.addOverloadedGetterSetter(n, t);
+  },
+  addOverloadedGetterSetter(n, t) {
+    const e = c._capitalize(t), i = j + e, s = W + e;
+    n.prototype[t] = function() {
+      return arguments.length ? (this[i](arguments[0]), this) : this[s]();
+    };
+  },
+  addDeprecatedGetterSetter(n, t, e, i) {
+    c.error("Adding deprecated " + t);
+    const s = W + c._capitalize(t), r = t + " property is deprecated and will be removed soon. Look at Konva change log for more information.";
+    n.prototype[s] = function() {
+      c.error(r);
+      const a = this.attrs[t];
+      return a === void 0 ? e : a;
+    }, g.addSetter(n, t, i, function() {
+      c.error(r);
+    }), g.addOverloadedGetterSetter(n, t);
+  },
+  backCompat(n, t) {
+    c.each(t, function(e, i) {
+      const s = n.prototype[i], r = W + c._capitalize(e), a = j + c._capitalize(e);
+      function o() {
+        s.apply(this, arguments), c.error('"' + e + '" method is deprecated and will be removed soon. Use ""' + i + '" instead.');
+      }
+      n.prototype[e] = o, n.prototype[r] = o, n.prototype[a] = o;
+    });
+  },
+  afterSetFilter() {
+    this._filterUpToDate = !1;
+  }
+};
+function Ue(n) {
+  const t = /(\w+)\(([^)]+)\)/g;
+  let e;
+  for (; (e = t.exec(n)) !== null; ) {
+    const [, i, s] = e;
+    switch (i) {
+      case "blur": {
+        const r = parseFloat(s.replace("px", ""));
+        return function(a) {
+          this.blurRadius(r * 0.5);
+          const o = m.Filters;
+          o && o.Blur && o.Blur.call(this, a);
+        };
+      }
+      case "brightness": {
+        const r = s.includes("%") ? parseFloat(s) / 100 : parseFloat(s);
+        return function(a) {
+          this.brightness(r);
+          const o = m.Filters;
+          o && o.Brightness && o.Brightness.call(this, a);
+        };
+      }
+      case "contrast": {
+        const r = parseFloat(s);
+        return function(a) {
+          const o = 100 * (Math.sqrt(r) - 1);
+          this.contrast(o);
+          const h = m.Filters;
+          h && h.Contrast && h.Contrast.call(this, a);
+        };
+      }
+      case "grayscale":
+        return function(r) {
+          const a = m.Filters;
+          a && a.Grayscale && a.Grayscale.call(this, r);
+        };
+      case "sepia":
+        return function(r) {
+          const a = m.Filters;
+          a && a.Sepia && a.Sepia.call(this, r);
+        };
+      case "invert":
+        return function(r) {
+          const a = m.Filters;
+          a && a.Invert && a.Invert.call(this, r);
+        };
+      default:
+        c.warn(`CSS filter "${i}" is not supported in fallback mode. Consider using function filters for better compatibility.`);
+        break;
+    }
+  }
+  return () => {
+  };
+}
+const dt = "absoluteOpacity", It = "allEventListeners", T = "absoluteTransform", Mt = "absoluteScale", F = "canvas", Ye = "Change", Xe = "children", Ve = "konva", vt = "listening", We = "mouseenter", je = "mouseleave", Ke = "pointerenter", qe = "pointerleave", ze = "touchenter", Je = "touchleave", Ft = "set", Bt = "Shape", ut = " ", Nt = "stage", O = "transform", $e = "Stage", bt = "visible", Ze = [
+  "xChange.konva",
+  "yChange.konva",
+  "scaleXChange.konva",
+  "scaleYChange.konva",
+  "skewXChange.konva",
+  "skewYChange.konva",
+  "rotationChange.konva",
+  "offsetXChange.konva",
+  "offsetYChange.konva",
+  "transformsEnabledChange.konva"
+].join(ut);
+let Qe = 1;
+class _ {
+  constructor(t) {
+    this._id = Qe++, this.eventListeners = {}, this.attrs = {}, this.index = 0, this._allEventListeners = null, this.parent = null, this._cache = /* @__PURE__ */ new Map(), this._attachedDepsListeners = /* @__PURE__ */ new Map(), this._lastPos = null, this._batchingTransformChange = !1, this._needClearTransformCache = !1, this._filterUpToDate = !1, this._isUnderCache = !1, this._dragEventId = null, this._shouldFireChangeEvents = !1, this.setAttrs(t), this._shouldFireChangeEvents = !0;
+  }
+  hasChildren() {
+    return !1;
+  }
+  _clearCache(t) {
+    (t === O || t === T) && this._cache.get(t) ? this._cache.get(t).dirty = !0 : t ? this._cache.delete(t) : this._cache.clear();
+  }
+  _getCache(t, e) {
+    let i = this._cache.get(t);
+    return (i === void 0 || (t === O || t === T) && i.dirty === !0) && (i = e.call(this), this._cache.set(t, i)), i;
+  }
+  _calculate(t, e, i) {
+    if (!this._attachedDepsListeners.get(t)) {
+      const s = e.map((r) => r + "Change.konva").join(ut);
+      this.on(s, () => {
+        this._clearCache(t);
+      }), this._attachedDepsListeners.set(t, !0);
+    }
+    return this._getCache(t, i);
+  }
+  _getCanvasCache() {
+    return this._cache.get(F);
+  }
+  _clearSelfAndDescendantCache(t) {
+    this._clearCache(t), t === T && this.fire("absoluteTransformChange");
+  }
+  clearCache() {
+    if (this._cache.has(F)) {
+      const { scene: t, filter: e, hit: i } = this._cache.get(F);
+      c.releaseCanvas(t._canvas, e._canvas, i._canvas), this._cache.delete(F);
+    }
+    return this._clearSelfAndDescendantCache(), this._requestDraw(), this;
+  }
+  cache(t) {
+    const e = t || {};
+    let i = {};
+    (e.x === void 0 || e.y === void 0 || e.width === void 0 || e.height === void 0) && (i = this.getClientRect({
+      skipTransform: !0,
+      relativeTo: this.getParent() || void 0
+    }));
+    let s = Math.ceil(e.width || i.width), r = Math.ceil(e.height || i.height), a = e.pixelRatio, o = e.x === void 0 ? Math.floor(i.x) : e.x, h = e.y === void 0 ? Math.floor(i.y) : e.y, l = e.offset || 0, d = e.drawBorder || !1, u = e.hitCanvasPixelRatio || 1;
+    if (!s || !r) {
+      c.error("Can not cache the node. Width or height of the node equals 0. Caching is skipped.");
+      return;
+    }
+    const f = Math.abs(Math.round(i.x) - o) > 0.5 ? 1 : 0, C = Math.abs(Math.round(i.y) - h) > 0.5 ? 1 : 0;
+    s += l * 2 + f, r += l * 2 + C, o -= l, h -= l;
+    const y = new D({
+      pixelRatio: a,
+      width: s,
+      height: r
+    }), P = new D({
+      pixelRatio: a,
+      width: 0,
+      height: 0,
+      willReadFrequently: !0
+    }), E = new Et({
+      pixelRatio: u,
+      width: s,
+      height: r
+    }), x = y.getContext(), A = E.getContext(), G = new D({
+      width: y.width / y.pixelRatio + Math.abs(o),
+      height: y.height / y.pixelRatio + Math.abs(h),
+      pixelRatio: y.pixelRatio
+    }), Tt = G.getContext();
+    return E.isCache = !0, y.isCache = !0, this._cache.delete(F), this._filterUpToDate = !1, e.imageSmoothingEnabled === !1 && (y.getContext()._context.imageSmoothingEnabled = !1, P.getContext()._context.imageSmoothingEnabled = !1), x.save(), A.save(), Tt.save(), x.translate(-o, -h), A.translate(-o, -h), Tt.translate(-o, -h), G.x = o, G.y = h, this._isUnderCache = !0, this._clearSelfAndDescendantCache(dt), this._clearSelfAndDescendantCache(Mt), this.drawScene(y, this, G), this.drawHit(E, this), this._isUnderCache = !1, x.restore(), A.restore(), d && (x.save(), x.beginPath(), x.rect(0, 0, s, r), x.closePath(), x.setAttr("strokeStyle", "red"), x.setAttr("lineWidth", 5), x.stroke(), x.restore()), c.releaseCanvas(G._canvas), this._cache.set(F, {
+      scene: y,
+      filter: P,
+      hit: E,
+      x: o,
+      y: h
+    }), this._requestDraw(), this;
+  }
+  isCached() {
+    return this._cache.has(F);
+  }
+  getClientRect(t) {
+    throw new Error('abstract "getClientRect" method call');
+  }
+  _transformedRect(t, e) {
+    const i = [
+      { x: t.x, y: t.y },
+      { x: t.x + t.width, y: t.y },
+      { x: t.x + t.width, y: t.y + t.height },
+      { x: t.x, y: t.y + t.height }
+    ];
+    let s = 1 / 0, r = 1 / 0, a = -1 / 0, o = -1 / 0;
+    const h = this.getAbsoluteTransform(e);
+    return i.forEach(function(l) {
+      const d = h.point(l);
+      s === void 0 && (s = a = d.x, r = o = d.y), s = Math.min(s, d.x), r = Math.min(r, d.y), a = Math.max(a, d.x), o = Math.max(o, d.y);
+    }), {
+      x: s,
+      y: r,
+      width: a - s,
+      height: o - r
+    };
+  }
+  _drawCachedSceneCanvas(t) {
+    t.save(), t._applyOpacity(this), t._applyGlobalCompositeOperation(this);
+    const e = this._getCanvasCache();
+    t.translate(e.x, e.y);
+    const i = this._getCachedSceneCanvas(), s = i.pixelRatio;
+    t.drawImage(i._canvas, 0, 0, i.width / s, i.height / s), t.restore();
+  }
+  _drawCachedHitCanvas(t) {
+    const e = this._getCanvasCache(), i = e.hit;
+    t.save(), t.translate(e.x, e.y), t.drawImage(i._canvas, 0, 0, i.width / i.pixelRatio, i.height / i.pixelRatio), t.restore();
+  }
+  _getCachedSceneCanvas() {
+    let t = this.filters(), e = this._getCanvasCache(), i = e.scene, s = e.filter, r = s.getContext(), a, o, h, l;
+    if (!t || t.length === 0)
+      return i;
+    if (this._filterUpToDate)
+      return s;
+    let d = !0;
+    for (let f = 0; f < t.length; f++)
+      if (typeof t[f] == "string" && Lt(), typeof t[f] != "string" || !Lt()) {
+        d = !1;
+        break;
+      }
+    const u = i.pixelRatio;
+    if (s.setSize(i.width / i.pixelRatio, i.height / i.pixelRatio), d) {
+      const f = t.join(" ");
+      return r.save(), r.setAttr("filter", f), r.drawImage(i._canvas, 0, 0, i.getWidth() / u, i.getHeight() / u), r.restore(), this._filterUpToDate = !0, s;
+    }
+    try {
+      for (a = t.length, r.clear(), r.drawImage(i._canvas, 0, 0, i.getWidth() / u, i.getHeight() / u), o = r.getImageData(0, 0, s.getWidth(), s.getHeight()), h = 0; h < a; h++)
+        l = t[h], typeof l == "string" && (l = Ue(l)), l.call(this, o), r.putImageData(o, 0, 0);
+    } catch (f) {
+      c.error("Unable to apply filter. " + f.message + " This post my help you https://konvajs.org/docs/posts/Tainted_Canvas.html.");
+    }
+    return this._filterUpToDate = !0, s;
+  }
+  on(...t) {
+    const e = t[0], i = t[1];
+    if (t[2], this._cache && this._cache.delete(It), t.length === 3)
+      return this._delegate.apply(this, t);
+    const s = e.split(ut);
+    for (let r = 0; r < s.length; r++) {
+      const o = s[r].split("."), h = o[0], l = o[1] || "";
+      this.eventListeners[h] || (this.eventListeners[h] = []), this.eventListeners[h].push({ name: l, handler: i });
+    }
+    return this;
+  }
+  off(t, e) {
+    let i = (t || "").split(ut), s = i.length, r, a, o, h, l, d;
+    if (this._cache && this._cache.delete(It), !t)
+      for (a in this.eventListeners)
+        this._off(a);
+    for (r = 0; r < s; r++)
+      if (o = i[r], h = o.split("."), l = h[0], d = h[1], l)
+        this.eventListeners[l] && this._off(l, d, e);
+      else
+        for (a in this.eventListeners)
+          this._off(a, d, e);
+    return this;
+  }
+  dispatchEvent(t) {
+    const e = {
+      target: this,
+      type: t.type,
+      evt: t
+    };
+    return this.fire(t.type, e), this;
+  }
+  addEventListener(t, e) {
+    return this.on(t, function(i) {
+      e.call(this, i.evt);
+    }), this;
+  }
+  removeEventListener(t) {
+    return this.off(t), this;
+  }
+  _delegate(t, e, i) {
+    const s = this;
+    return this.on(t, function(r) {
+      const a = r.target.findAncestors(e, !0, s);
+      for (let o = 0; o < a.length; o++)
+        r = c.cloneObject(r), r.currentTarget = a[o], i.call(a[o], r);
+    }), this;
+  }
+  remove() {
+    return this.isDragging() && this.stopDrag(), v._dragElements.delete(this._id), v._dragElements.forEach((t, e) => {
+      this.isAncestorOf(t.node) && v._dragElements.delete(e);
+    }), this._remove(), this;
+  }
+  _clearCaches() {
+    this._clearSelfAndDescendantCache(T), this._clearSelfAndDescendantCache(dt), this._clearSelfAndDescendantCache(Mt), this._clearSelfAndDescendantCache(Nt), this._clearSelfAndDescendantCache(bt), this._clearSelfAndDescendantCache(vt);
+  }
+  _remove() {
+    this._clearCaches();
+    const t = this.getParent();
+    t && t.children && (t.children.splice(this.index, 1), t._setChildrenIndices(), this.parent = null);
+  }
+  destroy() {
+    return this.remove(), this.clearCache(), this;
+  }
+  getAttr(t) {
+    const e = "get" + c._capitalize(t);
+    return c._isFunction(this[e]) ? this[e]() : this.attrs[t];
+  }
+  getAncestors() {
+    let t = this.getParent(), e = [];
+    for (; t; )
+      e.push(t), t = t.getParent();
+    return e;
+  }
+  getAttrs() {
+    return this.attrs || {};
+  }
+  setAttrs(t) {
+    return this._batchTransformChanges(() => {
+      let e, i;
+      if (!t)
+        return this;
+      for (e in t)
+        e !== Xe && (i = Ft + c._capitalize(e), c._isFunction(this[i]) ? this[i](t[e]) : this._setAttr(e, t[e]));
+    }), this;
+  }
+  isListening() {
+    return this._getCache(vt, this._isListening);
+  }
+  _isListening(t) {
+    if (!this.listening())
+      return !1;
+    const i = this.getParent();
+    return i && i !== t && this !== t ? i._isListening(t) : !0;
+  }
+  isVisible() {
+    return this._getCache(bt, this._isVisible);
+  }
+  _isVisible(t) {
+    if (!this.visible())
+      return !1;
+    const i = this.getParent();
+    return i && i !== t && this !== t ? i._isVisible(t) : !0;
+  }
+  shouldDrawHit(t, e = !1) {
+    if (t)
+      return this._isVisible(t) && this._isListening(t);
+    const i = this.getLayer();
+    let s = !1;
+    v._dragElements.forEach((a) => {
+      a.dragStatus === "dragging" && (a.node.nodeType === "Stage" || a.node.getLayer() === i) && (s = !0);
+    });
+    const r = !e && !m.hitOnDragEnabled && (s || m.isTransforming());
+    return this.isListening() && this.isVisible() && !r;
+  }
+  show() {
+    return this.visible(!0), this;
+  }
+  hide() {
+    return this.visible(!1), this;
+  }
+  getZIndex() {
+    return this.index || 0;
+  }
+  getAbsoluteZIndex() {
+    let t = this.getDepth(), e = this, i = 0, s, r, a, o;
+    function h(d) {
+      for (s = [], r = d.length, a = 0; a < r; a++)
+        o = d[a], i++, o.nodeType !== Bt && (s = s.concat(o.getChildren().slice())), o._id === e._id && (a = r);
+      s.length > 0 && s[0].getDepth() <= t && h(s);
+    }
+    const l = this.getStage();
+    return e.nodeType !== $e && l && h(l.getChildren()), i;
+  }
+  getDepth() {
+    let t = 0, e = this.parent;
+    for (; e; )
+      t++, e = e.parent;
+    return t;
+  }
+  _batchTransformChanges(t) {
+    this._batchingTransformChange = !0, t(), this._batchingTransformChange = !1, this._needClearTransformCache && (this._clearCache(O), this._clearSelfAndDescendantCache(T)), this._needClearTransformCache = !1;
+  }
+  setPosition(t) {
+    return this._batchTransformChanges(() => {
+      this.x(t.x), this.y(t.y);
+    }), this;
+  }
+  getPosition() {
+    return {
+      x: this.x(),
+      y: this.y()
+    };
+  }
+  getRelativePointerPosition() {
+    const t = this.getStage();
+    if (!t)
+      return null;
+    const e = t.getPointerPosition();
+    if (!e)
+      return null;
+    const i = this.getAbsoluteTransform().copy();
+    return i.invert(), i.point(e);
+  }
+  getAbsolutePosition(t) {
+    let e = !1, i = this.parent;
+    for (; i; ) {
+      if (i.isCached()) {
+        e = !0;
+        break;
+      }
+      i = i.parent;
+    }
+    e && !t && (t = !0);
+    const s = this.getAbsoluteTransform(t).getMatrix(), r = new L(), a = this.offset();
+    return r.m = s.slice(), r.translate(a.x, a.y), r.getTranslation();
+  }
+  setAbsolutePosition(t) {
+    const { x: e, y: i, ...s } = this._clearTransform();
+    this.attrs.x = e, this.attrs.y = i, this._clearCache(O);
+    const r = this._getAbsoluteTransform().copy();
+    return r.invert(), r.translate(t.x, t.y), t = {
+      x: this.attrs.x + r.getTranslation().x,
+      y: this.attrs.y + r.getTranslation().y
+    }, this._setTransform(s), this.setPosition({ x: t.x, y: t.y }), this._clearCache(O), this._clearSelfAndDescendantCache(T), this;
+  }
+  _setTransform(t) {
+    let e;
+    for (e in t)
+      this.attrs[e] = t[e];
+  }
+  _clearTransform() {
+    const t = {
+      x: this.x(),
+      y: this.y(),
+      rotation: this.rotation(),
+      scaleX: this.scaleX(),
+      scaleY: this.scaleY(),
+      offsetX: this.offsetX(),
+      offsetY: this.offsetY(),
+      skewX: this.skewX(),
+      skewY: this.skewY()
+    };
+    return this.attrs.x = 0, this.attrs.y = 0, this.attrs.rotation = 0, this.attrs.scaleX = 1, this.attrs.scaleY = 1, this.attrs.offsetX = 0, this.attrs.offsetY = 0, this.attrs.skewX = 0, this.attrs.skewY = 0, t;
+  }
+  move(t) {
+    let e = t.x, i = t.y, s = this.x(), r = this.y();
+    return e !== void 0 && (s += e), i !== void 0 && (r += i), this.setPosition({ x: s, y: r }), this;
+  }
+  _eachAncestorReverse(t, e) {
+    let i = [], s = this.getParent(), r, a;
+    if (!(e && e._id === this._id)) {
+      for (i.unshift(this); s && (!e || s._id !== e._id); )
+        i.unshift(s), s = s.parent;
+      for (r = i.length, a = 0; a < r; a++)
+        t(i[a]);
+    }
+  }
+  rotate(t) {
+    return this.rotation(this.rotation() + t), this;
+  }
+  moveToTop() {
+    if (!this.parent)
+      return c.warn("Node has no parent. moveToTop function is ignored."), !1;
+    const t = this.index, e = this.parent.getChildren().length;
+    return t < e - 1 ? (this.parent.children.splice(t, 1), this.parent.children.push(this), this.parent._setChildrenIndices(), !0) : !1;
+  }
+  moveUp() {
+    if (!this.parent)
+      return c.warn("Node has no parent. moveUp function is ignored."), !1;
+    const t = this.index, e = this.parent.getChildren().length;
+    return t < e - 1 ? (this.parent.children.splice(t, 1), this.parent.children.splice(t + 1, 0, this), this.parent._setChildrenIndices(), !0) : !1;
+  }
+  moveDown() {
+    if (!this.parent)
+      return c.warn("Node has no parent. moveDown function is ignored."), !1;
+    const t = this.index;
+    return t > 0 ? (this.parent.children.splice(t, 1), this.parent.children.splice(t - 1, 0, this), this.parent._setChildrenIndices(), !0) : !1;
+  }
+  moveToBottom() {
+    if (!this.parent)
+      return c.warn("Node has no parent. moveToBottom function is ignored."), !1;
+    const t = this.index;
+    return t > 0 ? (this.parent.children.splice(t, 1), this.parent.children.unshift(this), this.parent._setChildrenIndices(), !0) : !1;
+  }
+  setZIndex(t) {
+    if (!this.parent)
+      return c.warn("Node has no parent. zIndex parameter is ignored."), this;
+    (t < 0 || t >= this.parent.children.length) && c.warn("Unexpected value " + t + " for zIndex property. zIndex is just index of a node in children of its parent. Expected value is from 0 to " + (this.parent.children.length - 1) + ".");
+    const e = this.index;
+    return this.parent.children.splice(e, 1), this.parent.children.splice(t, 0, this), this.parent._setChildrenIndices(), this;
+  }
+  getAbsoluteOpacity() {
+    return this._getCache(dt, this._getAbsoluteOpacity);
+  }
+  _getAbsoluteOpacity() {
+    let t = this.opacity();
+    const e = this.getParent();
+    return e && !e._isUnderCache && (t *= e.getAbsoluteOpacity()), t;
+  }
+  moveTo(t) {
+    return this.getParent() !== t && (this._remove(), t.add(this)), this;
+  }
+  toObject() {
+    let t = this.getAttrs(), e, i, s, r, a;
+    const o = {
+      attrs: {},
+      className: this.getClassName()
+    };
+    for (e in t)
+      i = t[e], a = c.isObject(i) && !c._isPlainObject(i) && !c._isArray(i), !a && (s = typeof this[e] == "function" && this[e], delete t[e], r = s ? s.call(this) : null, t[e] = i, r !== i && (o.attrs[e] = i));
+    return c._prepareToStringify(o);
+  }
+  toJSON() {
+    return JSON.stringify(this.toObject());
+  }
+  getParent() {
+    return this.parent;
+  }
+  findAncestors(t, e, i) {
+    const s = [];
+    e && this._isMatch(t) && s.push(this);
+    let r = this.parent;
+    for (; r; ) {
+      if (r === i)
+        return s;
+      r._isMatch(t) && s.push(r), r = r.parent;
+    }
+    return s;
+  }
+  isAncestorOf(t) {
+    return !1;
+  }
+  findAncestor(t, e, i) {
+    return this.findAncestors(t, e, i)[0];
+  }
+  _isMatch(t) {
+    if (!t)
+      return !1;
+    if (typeof t == "function")
+      return t(this);
+    let e = t.replace(/ /g, "").split(","), i = e.length, s, r;
+    for (s = 0; s < i; s++)
+      if (r = e[s], c.isValidSelector(r) || (c.warn('Selector "' + r + '" is invalid. Allowed selectors examples are "#foo", ".bar" or "Group".'), c.warn('If you have a custom shape with such className, please change it to start with upper letter like "Triangle".'), c.warn("Konva is awesome, right?")), r.charAt(0) === "#") {
+        if (this.id() === r.slice(1))
+          return !0;
+      } else if (r.charAt(0) === ".") {
+        if (this.hasName(r.slice(1)))
+          return !0;
+      } else if (this.className === r || this.nodeType === r)
+        return !0;
+    return !1;
+  }
+  getLayer() {
+    const t = this.getParent();
+    return t ? t.getLayer() : null;
+  }
+  getStage() {
+    return this._getCache(Nt, this._getStage);
+  }
+  _getStage() {
+    const t = this.getParent();
+    return t ? t.getStage() : null;
+  }
+  fire(t, e = {}, i) {
+    return e.target = e.target || this, i ? this._fireAndBubble(t, e) : this._fire(t, e), this;
+  }
+  getAbsoluteTransform(t) {
+    return t ? this._getAbsoluteTransform(t) : this._getCache(T, this._getAbsoluteTransform);
+  }
+  _getAbsoluteTransform(t) {
+    let e;
+    if (t)
+      return e = new L(), this._eachAncestorReverse(function(i) {
+        const s = i.transformsEnabled();
+        s === "all" ? e.multiply(i.getTransform()) : s === "position" && e.translate(i.x() - i.offsetX(), i.y() - i.offsetY());
+      }, t), e;
+    {
+      e = this._cache.get(T) || new L(), this.parent ? this.parent.getAbsoluteTransform().copyInto(e) : e.reset();
+      const i = this.transformsEnabled();
+      if (i === "all")
+        e.multiply(this.getTransform());
+      else if (i === "position") {
+        const s = this.attrs.x || 0, r = this.attrs.y || 0, a = this.attrs.offsetX || 0, o = this.attrs.offsetY || 0;
+        e.translate(s - a, r - o);
+      }
+      return e.dirty = !1, e;
+    }
+  }
+  getAbsoluteScale(t) {
+    let e = this;
+    for (; e; )
+      e._isUnderCache && (t = e), e = e.getParent();
+    const s = this.getAbsoluteTransform(t).decompose();
+    return {
+      x: s.scaleX,
+      y: s.scaleY
+    };
+  }
+  getAbsoluteRotation() {
+    return this.getAbsoluteTransform().decompose().rotation;
+  }
+  getTransform() {
+    return this._getCache(O, this._getTransform);
+  }
+  _getTransform() {
+    var t, e;
+    const i = this._cache.get(O) || new L();
+    i.reset();
+    const s = this.x(), r = this.y(), a = m.getAngle(this.rotation()), o = (t = this.attrs.scaleX) !== null && t !== void 0 ? t : 1, h = (e = this.attrs.scaleY) !== null && e !== void 0 ? e : 1, l = this.attrs.skewX || 0, d = this.attrs.skewY || 0, u = this.attrs.offsetX || 0, f = this.attrs.offsetY || 0;
+    return (s !== 0 || r !== 0) && i.translate(s, r), a !== 0 && i.rotate(a), (l !== 0 || d !== 0) && i.skew(l, d), (o !== 1 || h !== 1) && i.scale(o, h), (u !== 0 || f !== 0) && i.translate(-1 * u, -1 * f), i.dirty = !1, i;
+  }
+  clone(t) {
+    let e = c.cloneObject(this.attrs), i, s, r, a, o;
+    for (i in t)
+      e[i] = t[i];
+    const h = new this.constructor(e);
+    for (i in this.eventListeners)
+      for (s = this.eventListeners[i], r = s.length, a = 0; a < r; a++)
+        o = s[a], o.name.indexOf(Ve) < 0 && (h.eventListeners[i] || (h.eventListeners[i] = []), h.eventListeners[i].push(o));
+    return h;
+  }
+  _toKonvaCanvas(t) {
+    t = t || {};
+    const e = this.getClientRect(), i = this.getStage(), s = t.x !== void 0 ? t.x : Math.floor(e.x), r = t.y !== void 0 ? t.y : Math.floor(e.y), a = t.pixelRatio || 1, o = new D({
+      width: t.width || Math.ceil(e.width) || (i ? i.width() : 0),
+      height: t.height || Math.ceil(e.height) || (i ? i.height() : 0),
+      pixelRatio: a
+    }), h = o.getContext(), l = new D({
+      width: o.width / o.pixelRatio + Math.abs(s),
+      height: o.height / o.pixelRatio + Math.abs(r),
+      pixelRatio: o.pixelRatio
+    });
+    return t.imageSmoothingEnabled === !1 && (h._context.imageSmoothingEnabled = !1), h.save(), (s || r) && h.translate(-1 * s, -1 * r), this.drawScene(o, void 0, l), h.restore(), o;
+  }
+  toCanvas(t) {
+    return this._toKonvaCanvas(t)._canvas;
+  }
+  toDataURL(t) {
+    t = t || {};
+    const e = t.mimeType || null, i = t.quality || null, s = this._toKonvaCanvas(t).toDataURL(e, i);
+    return t.callback && t.callback(s), s;
+  }
+  toImage(t) {
+    return new Promise((e, i) => {
+      try {
+        const s = t?.callback;
+        s && delete t.callback, c._urlToImage(this.toDataURL(t), function(r) {
+          e(r), s?.(r);
+        });
+      } catch (s) {
+        i(s);
+      }
+    });
+  }
+  toBlob(t) {
+    return new Promise((e, i) => {
+      try {
+        const s = t?.callback;
+        s && delete t.callback, this.toCanvas(t).toBlob((r) => {
+          e(r), s?.(r);
+        }, t?.mimeType, t?.quality);
+      } catch (s) {
+        i(s);
+      }
+    });
+  }
+  setSize(t) {
+    return this.width(t.width), this.height(t.height), this;
+  }
+  getSize() {
+    return {
+      width: this.width(),
+      height: this.height()
+    };
+  }
+  getClassName() {
+    return this.className || this.nodeType;
+  }
+  getType() {
+    return this.nodeType;
+  }
+  getDragDistance() {
+    return this.attrs.dragDistance !== void 0 ? this.attrs.dragDistance : this.parent ? this.parent.getDragDistance() : m.dragDistance;
+  }
+  _off(t, e, i) {
+    let s = this.eventListeners[t], r, a, o;
+    for (r = 0; r < s.length; r++)
+      if (a = s[r].name, o = s[r].handler, (a !== "konva" || e === "konva") && (!e || a === e) && (!i || i === o)) {
+        if (s.splice(r, 1), s.length === 0) {
+          delete this.eventListeners[t];
+          break;
+        }
+        r--;
+      }
+  }
+  _fireChangeEvent(t, e, i) {
+    this._fire(t + Ye, {
+      oldVal: e,
+      newVal: i
+    });
+  }
+  addName(t) {
+    if (!this.hasName(t)) {
+      const e = this.name(), i = e ? e + " " + t : t;
+      this.name(i);
+    }
+    return this;
+  }
+  hasName(t) {
+    if (!t)
+      return !1;
+    const e = this.name();
+    return e ? (e || "").split(/\s/g).indexOf(t) !== -1 : !1;
+  }
+  removeName(t) {
+    const e = (this.name() || "").split(/\s/g), i = e.indexOf(t);
+    return i !== -1 && (e.splice(i, 1), this.name(e.join(" "))), this;
+  }
+  setAttr(t, e) {
+    const i = this[Ft + c._capitalize(t)];
+    return c._isFunction(i) ? i.call(this, e) : this._setAttr(t, e), this;
+  }
+  _requestDraw() {
+    if (m.autoDrawEnabled) {
+      const t = this.getLayer() || this.getStage();
+      t?.batchDraw();
+    }
+  }
+  _setAttr(t, e) {
+    const i = this.attrs[t];
+    i === e && !c.isObject(e) || (e == null ? delete this.attrs[t] : this.attrs[t] = e, this._shouldFireChangeEvents && this._fireChangeEvent(t, i, e), this._requestDraw());
+  }
+  _setComponentAttr(t, e, i) {
+    let s;
+    i !== void 0 && (s = this.attrs[t], s || (this.attrs[t] = this.getAttr(t)), this.attrs[t][e] = i, this._fireChangeEvent(t, s, i));
+  }
+  _fireAndBubble(t, e, i) {
+    e && this.nodeType === Bt && (e.target = this);
+    const s = [
+      We,
+      je,
+      Ke,
+      qe,
+      ze,
+      Je
+    ];
+    if (!(s.indexOf(t) !== -1 && (i && (this === i || this.isAncestorOf && this.isAncestorOf(i)) || this.nodeType === "Stage" && !i))) {
+      this._fire(t, e);
+      const a = s.indexOf(t) !== -1 && i && i.isAncestorOf && i.isAncestorOf(this) && !i.isAncestorOf(this.parent);
+      (e && !e.cancelBubble || !e) && this.parent && this.parent.isListening() && !a && (i && i.parent ? this._fireAndBubble.call(this.parent, t, e, i) : this._fireAndBubble.call(this.parent, t, e));
+    }
+  }
+  _getProtoListeners(t) {
+    var e, i;
+    const { nodeType: s } = this, r = _.protoListenerMap.get(s) || {};
+    let a = r?.[t];
+    if (a === void 0) {
+      a = [];
+      let o = Object.getPrototypeOf(this);
+      for (; o; ) {
+        const h = (i = (e = o.eventListeners) === null || e === void 0 ? void 0 : e[t]) !== null && i !== void 0 ? i : [];
+        a.push(...h), o = Object.getPrototypeOf(o);
+      }
+      r[t] = a, _.protoListenerMap.set(s, r);
+    }
+    return a;
+  }
+  _fire(t, e) {
+    e = e || {}, e.currentTarget = this, e.type = t;
+    const i = this._getProtoListeners(t);
+    if (i) {
+      const r = i.slice();
+      for (let a = 0; a < r.length; a++)
+        r[a].handler.call(this, e);
+    }
+    const s = this.eventListeners[t];
+    if (s) {
+      const r = s.slice(), a = r.length;
+      for (let h = 0; h < r.length; h++)
+        r[h].handler.call(this, e);
+      const o = this.eventListeners[t];
+      if (o)
+        for (let h = a; h < o.length; h++)
+          o[h].handler.call(this, e);
+    }
+  }
+  draw() {
+    return this.drawScene(), this.drawHit(), this;
+  }
+  _createDragElement(t) {
+    const e = t ? t.pointerId : void 0, i = this.getStage(), s = this.getAbsolutePosition();
+    if (!i)
+      return;
+    const r = i._getPointerById(e) || i._changedPointerPositions[0] || s;
+    v._dragElements.set(this._id, {
+      node: this,
+      startPointerPos: r,
+      offset: {
+        x: r.x - s.x,
+        y: r.y - s.y
+      },
+      dragStatus: "ready",
+      pointerId: e,
+      startEvent: t
+    });
+  }
+  startDrag(t, e = !0) {
+    v._dragElements.has(this._id) || this._createDragElement(t);
+    const i = v._dragElements.get(this._id);
+    i.dragStatus = "dragging", this.fire("dragstart", {
+      type: "dragstart",
+      target: this,
+      evt: i.startEvent && i.startEvent.evt || t && t.evt
+    }, e);
+  }
+  _setDragPosition(t, e) {
+    const i = this.getStage()._getPointerById(e.pointerId);
+    if (!i)
+      return;
+    let s = {
+      x: i.x - e.offset.x,
+      y: i.y - e.offset.y
+    };
+    const r = this.dragBoundFunc();
+    if (r !== void 0) {
+      const a = r.call(this, s, t);
+      a ? s = a : c.warn("dragBoundFunc did not return any value. That is unexpected behavior. You must return new absolute position from dragBoundFunc.");
+    }
+    (!this._lastPos || this._lastPos.x !== s.x || this._lastPos.y !== s.y) && (this.setAbsolutePosition(s), this._requestDraw()), this._lastPos = s;
+  }
+  stopDrag(t) {
+    const e = v._dragElements.get(this._id);
+    e && (e.dragStatus = "stopped"), v._endDragBefore(t), v._endDragAfter(t);
+  }
+  setDraggable(t) {
+    this._setAttr("draggable", t), this._dragChange();
+  }
+  isDragging() {
+    const t = v._dragElements.get(this._id);
+    return t ? t.dragStatus === "dragging" : !1;
+  }
+  _listenDrag() {
+    this._dragCleanup(), this.on("mousedown.konva touchstart.konva", function(t) {
+      if (!(!(t.evt.button !== void 0) || m.dragButtons.indexOf(t.evt.button) >= 0) || this.isDragging())
+        return;
+      let s = !1;
+      v._dragElements.forEach((r) => {
+        this.isAncestorOf(r.node) && (s = !0);
+      }), s || this._createDragElement(t);
+    });
+  }
+  _dragChange() {
+    if (this.attrs.draggable)
+      this._listenDrag();
+    else {
+      if (this._dragCleanup(), !this.getStage())
+        return;
+      const e = v._dragElements.get(this._id), i = e && e.dragStatus === "dragging", s = e && e.dragStatus === "ready";
+      i ? this.stopDrag() : s && v._dragElements.delete(this._id);
+    }
+  }
+  _dragCleanup() {
+    this.off("mousedown.konva"), this.off("touchstart.konva");
+  }
+  isClientRectOnScreen(t = { x: 0, y: 0 }) {
+    const e = this.getStage();
+    if (!e)
+      return !1;
+    const i = {
+      x: -t.x,
+      y: -t.y,
+      width: e.width() + 2 * t.x,
+      height: e.height() + 2 * t.y
+    };
+    return c.haveIntersection(i, this.getClientRect());
+  }
+  static create(t, e) {
+    return c._isString(t) && (t = JSON.parse(t)), this._createNode(t, e);
+  }
+  static _createNode(t, e) {
+    let i = _.prototype.getClassName.call(t), s = t.children, r, a, o;
+    e && (t.attrs.container = e), m[i] || (c.warn('Can not find a node with class name "' + i + '". Fallback to "Shape".'), i = "Shape");
+    const h = m[i];
+    if (r = new h(t.attrs), s)
+      for (a = s.length, o = 0; o < a; o++)
+        r.add(_._createNode(s[o]));
+    return r;
+  }
+}
+_.protoListenerMap = /* @__PURE__ */ new Map();
+_.prototype.nodeType = "Node";
+_.prototype._attrsAffectingSize = [];
+_.prototype.eventListeners = {};
+_.prototype.on(Ze, function() {
+  if (this._batchingTransformChange) {
+    this._needClearTransformCache = !0;
+    return;
+  }
+  this._clearCache(O), this._clearSelfAndDescendantCache(T);
+});
+_.prototype.on("visibleChange.konva", function() {
+  this._clearSelfAndDescendantCache(bt);
+});
+_.prototype.on("listeningChange.konva", function() {
+  this._clearSelfAndDescendantCache(vt);
+});
+_.prototype.on("opacityChange.konva", function() {
+  this._clearSelfAndDescendantCache(dt);
+});
+const S = g.addGetterSetter;
+S(_, "zIndex");
+S(_, "absolutePosition");
+S(_, "position");
+S(_, "x", 0, b());
+S(_, "y", 0, b());
+S(_, "globalCompositeOperation", "source-over", Y());
+S(_, "opacity", 1, b());
+S(_, "name", "", Y());
+S(_, "id", "", Y());
+S(_, "rotation", 0, b());
+g.addComponentsGetterSetter(_, "scale", ["x", "y"]);
+S(_, "scaleX", 1, b());
+S(_, "scaleY", 1, b());
+g.addComponentsGetterSetter(_, "skew", ["x", "y"]);
+S(_, "skewX", 0, b());
+S(_, "skewY", 0, b());
+g.addComponentsGetterSetter(_, "offset", ["x", "y"]);
+S(_, "offsetX", 0, b());
+S(_, "offsetY", 0, b());
+S(_, "dragDistance", void 0, b());
+S(_, "width", 0, b());
+S(_, "height", 0, b());
+S(_, "listening", !0, M());
+S(_, "preventDefault", !0, M());
+S(_, "filters", void 0, function(n) {
+  return this._filterUpToDate = !1, n;
+});
+S(_, "visible", !0, M());
+S(_, "transformsEnabled", "all", Y());
+S(_, "size");
+S(_, "dragBoundFunc");
+S(_, "draggable", !1, M());
+g.backCompat(_, {
+  rotateDeg: "rotate",
+  setRotationDeg: "setRotation",
+  getRotationDeg: "getRotation"
+});
+class k extends _ {
+  constructor() {
+    super(...arguments), this.children = [];
+  }
+  getChildren(t) {
+    const e = this.children || [];
+    return t ? e.filter(t) : e;
+  }
+  hasChildren() {
+    return this.getChildren().length > 0;
+  }
+  removeChildren() {
+    return this.getChildren().forEach((t) => {
+      t.parent = null, t.index = 0, t.remove();
+    }), this.children = [], this._requestDraw(), this;
+  }
+  destroyChildren() {
+    return this.getChildren().forEach((t) => {
+      t.parent = null, t.index = 0, t.destroy();
+    }), this.children = [], this._requestDraw(), this;
+  }
+  add(...t) {
+    if (t.length === 0)
+      return this;
+    if (t.length > 1) {
+      for (let i = 0; i < t.length; i++)
+        this.add(t[i]);
+      return this;
+    }
+    const e = t[0];
+    return e.getParent() ? (e.moveTo(this), this) : (this._validateAdd(e), e.index = this.getChildren().length, e.parent = this, e._clearCaches(), this.getChildren().push(e), this._fire("add", {
+      child: e
+    }), this._requestDraw(), this);
+  }
+  destroy() {
+    return this.hasChildren() && this.destroyChildren(), super.destroy(), this;
+  }
+  find(t) {
+    return this._generalFind(t, !1);
+  }
+  findOne(t) {
+    const e = this._generalFind(t, !0);
+    return e.length > 0 ? e[0] : void 0;
+  }
+  _generalFind(t, e) {
+    const i = [];
+    return this._descendants((s) => {
+      const r = s._isMatch(t);
+      return r && i.push(s), !!(r && e);
+    }), i;
+  }
+  _descendants(t) {
+    let e = !1;
+    const i = this.getChildren();
+    for (const s of i) {
+      if (e = t(s), e)
+        return !0;
+      if (s.hasChildren() && (e = s._descendants(t), e))
+        return !0;
+    }
+    return !1;
+  }
+  toObject() {
+    const t = _.prototype.toObject.call(this);
+    return t.children = [], this.getChildren().forEach((e) => {
+      t.children.push(e.toObject());
+    }), t;
+  }
+  isAncestorOf(t) {
+    let e = t.getParent();
+    for (; e; ) {
+      if (e._id === this._id)
+        return !0;
+      e = e.getParent();
+    }
+    return !1;
+  }
+  clone(t) {
+    const e = _.prototype.clone.call(this, t);
+    return this.getChildren().forEach(function(i) {
+      e.add(i.clone());
+    }), e;
+  }
+  getAllIntersections(t) {
+    const e = [];
+    return this.find("Shape").forEach((i) => {
+      i.isVisible() && i.intersects(t) && e.push(i);
+    }), e;
+  }
+  _clearSelfAndDescendantCache(t) {
+    var e;
+    super._clearSelfAndDescendantCache(t), !this.isCached() && ((e = this.children) === null || e === void 0 || e.forEach(function(i) {
+      i._clearSelfAndDescendantCache(t);
+    }));
+  }
+  _setChildrenIndices() {
+    var t;
+    (t = this.children) === null || t === void 0 || t.forEach(function(e, i) {
+      e.index = i;
+    }), this._requestDraw();
+  }
+  drawScene(t, e, i) {
+    const s = this.getLayer(), r = t || s && s.getCanvas(), a = r && r.getContext(), o = this._getCanvasCache(), h = o && o.scene, l = r && r.isCache;
+    if (!this.isVisible() && !l)
+      return this;
+    if (h) {
+      a.save();
+      const d = this.getAbsoluteTransform(e).getMatrix();
+      a.transform(d[0], d[1], d[2], d[3], d[4], d[5]), this._drawCachedSceneCanvas(a), a.restore();
+    } else
+      this._drawChildren("drawScene", r, e, i);
+    return this;
+  }
+  drawHit(t, e) {
+    if (!this.shouldDrawHit(e))
+      return this;
+    const i = this.getLayer(), s = t || i && i.hitCanvas, r = s && s.getContext(), a = this._getCanvasCache();
+    if (a && a.hit) {
+      r.save();
+      const h = this.getAbsoluteTransform(e).getMatrix();
+      r.transform(h[0], h[1], h[2], h[3], h[4], h[5]), this._drawCachedHitCanvas(r), r.restore();
+    } else
+      this._drawChildren("drawHit", s, e);
+    return this;
+  }
+  _drawChildren(t, e, i, s) {
+    var r;
+    const a = e && e.getContext(), o = this.clipWidth(), h = this.clipHeight(), l = this.clipFunc(), d = typeof o == "number" && typeof h == "number" || l, u = i === this;
+    if (d) {
+      a.save();
+      const C = this.getAbsoluteTransform(i);
+      let y = C.getMatrix();
+      a.transform(y[0], y[1], y[2], y[3], y[4], y[5]), a.beginPath();
+      let P;
+      if (l)
+        P = l.call(this, a, this);
+      else {
+        const E = this.clipX(), x = this.clipY();
+        a.rect(E || 0, x || 0, o, h);
+      }
+      a.clip.apply(a, P), y = C.copy().invert().getMatrix(), a.transform(y[0], y[1], y[2], y[3], y[4], y[5]);
+    }
+    const f = !u && this.globalCompositeOperation() !== "source-over" && t === "drawScene";
+    f && (a.save(), a._applyGlobalCompositeOperation(this)), (r = this.children) === null || r === void 0 || r.forEach(function(C) {
+      C[t](e, i, s);
+    }), f && a.restore(), d && a.restore();
+  }
+  getClientRect(t = {}) {
+    var e;
+    const i = t.skipTransform, s = t.relativeTo;
+    let r, a, o, h, l = {
+      x: 1 / 0,
+      y: 1 / 0,
+      width: 0,
+      height: 0
+    };
+    const d = this;
+    (e = this.children) === null || e === void 0 || e.forEach(function(C) {
+      if (!C.visible())
+        return;
+      const y = C.getClientRect({
+        relativeTo: d,
+        skipShadow: t.skipShadow,
+        skipStroke: t.skipStroke
+      });
+      y.width === 0 && y.height === 0 || (r === void 0 ? (r = y.x, a = y.y, o = y.x + y.width, h = y.y + y.height) : (r = Math.min(r, y.x), a = Math.min(a, y.y), o = Math.max(o, y.x + y.width), h = Math.max(h, y.y + y.height)));
+    });
+    const u = this.find("Shape");
+    let f = !1;
+    for (let C = 0; C < u.length; C++)
+      if (u[C]._isVisible(this)) {
+        f = !0;
+        break;
+      }
+    return f && r !== void 0 ? l = {
+      x: r,
+      y: a,
+      width: o - r,
+      height: h - a
+    } : l = {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    }, i ? l : this._transformedRect(l, s);
+  }
+}
+g.addComponentsGetterSetter(k, "clip", [
+  "x",
+  "y",
+  "width",
+  "height"
+]);
+g.addGetterSetter(k, "clipX", void 0, b());
+g.addGetterSetter(k, "clipY", void 0, b());
+g.addGetterSetter(k, "clipWidth", void 0, b());
+g.addGetterSetter(k, "clipHeight", void 0, b());
+g.addGetterSetter(k, "clipFunc");
+const it = /* @__PURE__ */ new Map(), jt = m._global.PointerEvent !== void 0;
+function mt(n) {
+  return it.get(n);
+}
+function Pt(n) {
+  return {
+    evt: n,
+    pointerId: n.pointerId
+  };
+}
+function Kt(n, t) {
+  return it.get(n) === t;
+}
+function qt(n, t) {
+  Z(n), t.getStage() && (it.set(n, t), jt && t._fire("gotpointercapture", Pt(new PointerEvent("gotpointercapture"))));
+}
+function Z(n, t) {
+  const e = it.get(n);
+  if (!e)
+    return;
+  const i = e.getStage();
+  i && i.content, it.delete(n), jt && e._fire("lostpointercapture", Pt(new PointerEvent("lostpointercapture")));
+}
+const ti = "Stage", ei = "string", Ht = "px", ii = "mouseout", zt = "mouseleave", Jt = "mouseover", $t = "mouseenter", Zt = "mousemove", Qt = "mousedown", te = "mouseup", K = "pointermove", q = "pointerdown", U = "pointerup", z = "pointercancel", ni = "lostpointercapture", ot = "pointerout", J = "pointerleave", ht = "pointerover", lt = "pointerenter", St = "contextmenu", ee = "touchstart", ie = "touchend", ne = "touchmove", se = "touchcancel", wt = "wheel", si = 5, ri = [
+  [$t, "_pointerenter"],
+  [Qt, "_pointerdown"],
+  [Zt, "_pointermove"],
+  [te, "_pointerup"],
+  [zt, "_pointerleave"],
+  [ee, "_pointerdown"],
+  [ne, "_pointermove"],
+  [ie, "_pointerup"],
+  [se, "_pointercancel"],
+  [Jt, "_pointerover"],
+  [wt, "_wheel"],
+  [St, "_contextmenu"],
+  [q, "_pointerdown"],
+  [K, "_pointermove"],
+  [U, "_pointerup"],
+  [z, "_pointercancel"],
+  [J, "_pointerleave"],
+  [ni, "_lostpointercapture"]
+], _t = {
+  mouse: {
+    [ot]: ii,
+    [J]: zt,
+    [ht]: Jt,
+    [lt]: $t,
+    [K]: Zt,
+    [q]: Qt,
+    [U]: te,
+    [z]: "mousecancel",
+    pointerclick: "click",
+    pointerdblclick: "dblclick"
+  },
+  touch: {
+    [ot]: "touchout",
+    [J]: "touchleave",
+    [ht]: "touchover",
+    [lt]: "touchenter",
+    [K]: ne,
+    [q]: ee,
+    [U]: ie,
+    [z]: se,
+    pointerclick: "tap",
+    pointerdblclick: "dbltap"
+  },
+  pointer: {
+    [ot]: ot,
+    [J]: J,
+    [ht]: ht,
+    [lt]: lt,
+    [K]: K,
+    [q]: q,
+    [U]: U,
+    [z]: z,
+    pointerclick: "pointerclick",
+    pointerdblclick: "pointerdblclick"
+  }
+}, $ = (n) => n.indexOf("pointer") >= 0 ? "pointer" : n.indexOf("touch") >= 0 ? "touch" : "mouse", H = (n) => {
+  const t = $(n);
+  if (t === "pointer")
+    return m.pointerEventsEnabled && _t.pointer;
+  if (t === "touch")
+    return _t.touch;
+  if (t === "mouse")
+    return _t.mouse;
+};
+function Ut(n = {}) {
+  return (n.clipFunc || n.clipWidth || n.clipHeight) && c.warn("Stage does not support clipping. Please use clip for Layers or Groups."), n;
+}
+const ai = "Pointer position is missing and not registered by the stage. Looks like it is outside of the stage container. You can set it manually from event: stage.setPointersPositions(event);", Q = [];
+class gt extends k {
+  constructor(t) {
+    super(Ut(t)), this._pointerPositions = [], this._changedPointerPositions = [], this._buildDOM(), this._bindContentEvents(), Q.push(this), this.on("widthChange.konva heightChange.konva", this._resizeDOM), this.on("visibleChange.konva", this._checkVisibility), this.on("clipWidthChange.konva clipHeightChange.konva clipFuncChange.konva", () => {
+      Ut(this.attrs);
+    }), this._checkVisibility();
+  }
+  _validateAdd(t) {
+    const e = t.getType() === "Layer", i = t.getType() === "FastLayer";
+    e || i || c.throw("You may only add layers to the stage.");
+  }
+  _checkVisibility() {
+    if (!this.content)
+      return;
+    const t = this.visible() ? "" : "none";
+    this.content.style.display = t;
+  }
+  setContainer(t) {
+    if (typeof t === ei) {
+      let e;
+      if (t.charAt(0) === ".") {
+        const i = t.slice(1);
+        t = document.getElementsByClassName(i)[0];
+      } else
+        t.charAt(0) !== "#" ? e = t : e = t.slice(1), t = document.getElementById(e);
+      if (!t)
+        throw "Can not find container in document with id " + e;
+    }
+    return this._setAttr("container", t), this.content && (this.content.parentElement && this.content.parentElement.removeChild(this.content), t.appendChild(this.content)), this;
+  }
+  shouldDrawHit() {
+    return !0;
+  }
+  clear() {
+    const t = this.children, e = t.length;
+    for (let i = 0; i < e; i++)
+      t[i].clear();
+    return this;
+  }
+  clone(t) {
+    return t || (t = {}), t.container = typeof document < "u" && document.createElement("div"), k.prototype.clone.call(this, t);
+  }
+  destroy() {
+    super.destroy();
+    const t = this.content;
+    t && c._isInDocument(t) && this.container().removeChild(t);
+    const e = Q.indexOf(this);
+    return e > -1 && Q.splice(e, 1), c.releaseCanvas(this.bufferCanvas._canvas, this.bufferHitCanvas._canvas), this;
+  }
+  getPointerPosition() {
+    const t = this._pointerPositions[0] || this._changedPointerPositions[0];
+    return t ? {
+      x: t.x,
+      y: t.y
+    } : (c.warn(ai), null);
+  }
+  _getPointerById(t) {
+    return this._pointerPositions.find((e) => e.id === t);
+  }
+  getPointersPositions() {
+    return this._pointerPositions;
+  }
+  getStage() {
+    return this;
+  }
+  getContent() {
+    return this.content;
+  }
+  _toKonvaCanvas(t) {
+    t = { ...t }, t.x = t.x || 0, t.y = t.y || 0, t.width = t.width || this.width(), t.height = t.height || this.height();
+    const e = new D({
+      width: t.width,
+      height: t.height,
+      pixelRatio: t.pixelRatio || 1
+    }), i = e.getContext()._context, s = this.children;
+    return (t.x || t.y) && i.translate(-1 * t.x, -1 * t.y), s.forEach(function(r) {
+      if (!r.isVisible())
+        return;
+      const a = r._toKonvaCanvas(t);
+      i.drawImage(a._canvas, t.x, t.y, a.getWidth() / a.getPixelRatio(), a.getHeight() / a.getPixelRatio());
+    }), e;
+  }
+  getIntersection(t) {
+    if (!t)
+      return null;
+    const e = this.children, i = e.length, s = i - 1;
+    for (let r = s; r >= 0; r--) {
+      const a = e[r].getIntersection(t);
+      if (a)
+        return a;
+    }
+    return null;
+  }
+  _resizeDOM() {
+    const t = this.width(), e = this.height();
+    this.content && (this.content.style.width = t + Ht, this.content.style.height = e + Ht), this.bufferCanvas.setSize(t, e), this.bufferHitCanvas.setSize(t, e), this.children.forEach((i) => {
+      i.setSize({ width: t, height: e }), i.draw();
+    });
+  }
+  add(t, ...e) {
+    if (arguments.length > 1) {
+      for (let s = 0; s < arguments.length; s++)
+        this.add(arguments[s]);
+      return this;
+    }
+    super.add(t);
+    const i = this.children.length;
+    return i > si && c.warn("The stage has " + i + " layers. Recommended maximum number of layers is 3-5. Adding more layers into the stage may drop the performance. Rethink your tree structure, you can use Konva.Group."), t.setSize({ width: this.width(), height: this.height() }), t.draw(), m.isBrowser && this.content.appendChild(t.canvas._canvas), this;
+  }
+  getParent() {
+    return null;
+  }
+  getLayer() {
+    return null;
+  }
+  hasPointerCapture(t) {
+    return Kt(t, this);
+  }
+  setPointerCapture(t) {
+    qt(t, this);
+  }
+  releaseCapture(t) {
+    Z(t);
+  }
+  getLayers() {
+    return this.children;
+  }
+  _bindContentEvents() {
+    m.isBrowser && ri.forEach(([t, e]) => {
+      this.content.addEventListener(t, (i) => {
+        this[e](i);
+      }, { passive: !1 });
+    });
+  }
+  _pointerenter(t) {
+    this.setPointersPositions(t);
+    const e = H(t.type);
+    e && this._fire(e.pointerenter, {
+      evt: t,
+      target: this,
+      currentTarget: this
+    });
+  }
+  _pointerover(t) {
+    this.setPointersPositions(t);
+    const e = H(t.type);
+    e && this._fire(e.pointerover, {
+      evt: t,
+      target: this,
+      currentTarget: this
+    });
+  }
+  _getTargetShape(t) {
+    let e = this[t + "targetShape"];
+    return e && !e.getStage() && (e = null), e;
+  }
+  _pointerleave(t) {
+    const e = H(t.type), i = $(t.type);
+    if (!e)
+      return;
+    this.setPointersPositions(t);
+    const s = this._getTargetShape(i), r = !(m.isDragging() || m.isTransforming()) || m.hitOnDragEnabled;
+    s && r ? (s._fireAndBubble(e.pointerout, { evt: t }), s._fireAndBubble(e.pointerleave, { evt: t }), this._fire(e.pointerleave, {
+      evt: t,
+      target: this,
+      currentTarget: this
+    }), this[i + "targetShape"] = null) : r && (this._fire(e.pointerleave, {
+      evt: t,
+      target: this,
+      currentTarget: this
+    }), this._fire(e.pointerout, {
+      evt: t,
+      target: this,
+      currentTarget: this
+    })), this.pointerPos = null, this._pointerPositions = [];
+  }
+  _pointerdown(t) {
+    const e = H(t.type), i = $(t.type);
+    if (!e)
+      return;
+    this.setPointersPositions(t);
+    let s = !1;
+    this._changedPointerPositions.forEach((r) => {
+      const a = this.getIntersection(r);
+      if (v.justDragged = !1, m["_" + i + "ListenClick"] = !0, !a || !a.isListening()) {
+        this[i + "ClickStartShape"] = void 0;
+        return;
+      }
+      m.capturePointerEventsEnabled && a.setPointerCapture(r.id), this[i + "ClickStartShape"] = a, a._fireAndBubble(e.pointerdown, {
+        evt: t,
+        pointerId: r.id
+      }), s = !0;
+      const o = t.type.indexOf("touch") >= 0;
+      a.preventDefault() && t.cancelable && o && t.preventDefault();
+    }), s || this._fire(e.pointerdown, {
+      evt: t,
+      target: this,
+      currentTarget: this,
+      pointerId: this._pointerPositions[0].id
+    });
+  }
+  _pointermove(t) {
+    const e = H(t.type), i = $(t.type);
+    if (!e)
+      return;
+    const s = t.type.indexOf("touch") >= 0 || t.pointerType === "touch";
+    if (m.isDragging() && v.node.preventDefault() && t.cancelable && s && t.preventDefault(), this.setPointersPositions(t), !(!(m.isDragging() || m.isTransforming()) || m.hitOnDragEnabled))
+      return;
+    const a = {};
+    let o = !1;
+    const h = this._getTargetShape(i);
+    this._changedPointerPositions.forEach((l) => {
+      const d = mt(l.id) || this.getIntersection(l), u = l.id, f = { evt: t, pointerId: u }, C = h !== d;
+      if (C && h && (h._fireAndBubble(e.pointerout, { ...f }, d), h._fireAndBubble(e.pointerleave, { ...f }, d)), d) {
+        if (a[d._id])
+          return;
+        a[d._id] = !0;
+      }
+      d && d.isListening() ? (o = !0, C && (d._fireAndBubble(e.pointerover, { ...f }, h), d._fireAndBubble(e.pointerenter, { ...f }, h), this[i + "targetShape"] = d), d._fireAndBubble(e.pointermove, { ...f })) : h && (this._fire(e.pointerover, {
+        evt: t,
+        target: this,
+        currentTarget: this,
+        pointerId: u
+      }), this[i + "targetShape"] = null);
+    }), o || this._fire(e.pointermove, {
+      evt: t,
+      target: this,
+      currentTarget: this,
+      pointerId: this._changedPointerPositions[0].id
+    });
+  }
+  _pointerup(t) {
+    const e = H(t.type), i = $(t.type);
+    if (!e)
+      return;
+    this.setPointersPositions(t);
+    const s = this[i + "ClickStartShape"], r = this[i + "ClickEndShape"], a = {};
+    let o = !1;
+    this._changedPointerPositions.forEach((h) => {
+      const l = mt(h.id) || this.getIntersection(h);
+      if (l) {
+        if (l.releaseCapture(h.id), a[l._id])
+          return;
+        a[l._id] = !0;
+      }
+      const d = h.id, u = { evt: t, pointerId: d };
+      let f = !1;
+      m["_" + i + "InDblClickWindow"] ? (f = !0, clearTimeout(this[i + "DblTimeout"])) : v.justDragged || (m["_" + i + "InDblClickWindow"] = !0, clearTimeout(this[i + "DblTimeout"])), this[i + "DblTimeout"] = setTimeout(function() {
+        m["_" + i + "InDblClickWindow"] = !1;
+      }, m.dblClickWindow), l && l.isListening() ? (o = !0, this[i + "ClickEndShape"] = l, l._fireAndBubble(e.pointerup, { ...u }), m["_" + i + "ListenClick"] && s && s === l && (l._fireAndBubble(e.pointerclick, { ...u }), f && r && r === l && l._fireAndBubble(e.pointerdblclick, { ...u }))) : (this[i + "ClickEndShape"] = null, o || (this._fire(e.pointerup, {
+        evt: t,
+        target: this,
+        currentTarget: this,
+        pointerId: this._changedPointerPositions[0].id
+      }), o = !0), m["_" + i + "ListenClick"] && this._fire(e.pointerclick, {
+        evt: t,
+        target: this,
+        currentTarget: this,
+        pointerId: d
+      }), f && this._fire(e.pointerdblclick, {
+        evt: t,
+        target: this,
+        currentTarget: this,
+        pointerId: d
+      }));
+    }), o || this._fire(e.pointerup, {
+      evt: t,
+      target: this,
+      currentTarget: this,
+      pointerId: this._changedPointerPositions[0].id
+    }), m["_" + i + "ListenClick"] = !1, t.cancelable && i !== "touch" && i !== "pointer" && t.preventDefault();
+  }
+  _contextmenu(t) {
+    this.setPointersPositions(t);
+    const e = this.getIntersection(this.getPointerPosition());
+    e && e.isListening() ? e._fireAndBubble(St, { evt: t }) : this._fire(St, {
+      evt: t,
+      target: this,
+      currentTarget: this
+    });
+  }
+  _wheel(t) {
+    this.setPointersPositions(t);
+    const e = this.getIntersection(this.getPointerPosition());
+    e && e.isListening() ? e._fireAndBubble(wt, { evt: t }) : this._fire(wt, {
+      evt: t,
+      target: this,
+      currentTarget: this
+    });
+  }
+  _pointercancel(t) {
+    this.setPointersPositions(t);
+    const e = mt(t.pointerId) || this.getIntersection(this.getPointerPosition());
+    e && e._fireAndBubble(U, Pt(t)), Z(t.pointerId);
+  }
+  _lostpointercapture(t) {
+    Z(t.pointerId);
+  }
+  setPointersPositions(t) {
+    const e = this._getContentPosition();
+    let i = null, s = null;
+    t = t || window.event, t.touches !== void 0 ? (this._pointerPositions = [], this._changedPointerPositions = [], Array.prototype.forEach.call(t.touches, (r) => {
+      this._pointerPositions.push({
+        id: r.identifier,
+        x: (r.clientX - e.left) / e.scaleX,
+        y: (r.clientY - e.top) / e.scaleY
+      });
+    }), Array.prototype.forEach.call(t.changedTouches || t.touches, (r) => {
+      this._changedPointerPositions.push({
+        id: r.identifier,
+        x: (r.clientX - e.left) / e.scaleX,
+        y: (r.clientY - e.top) / e.scaleY
+      });
+    })) : (i = (t.clientX - e.left) / e.scaleX, s = (t.clientY - e.top) / e.scaleY, this.pointerPos = {
+      x: i,
+      y: s
+    }, this._pointerPositions = [{ x: i, y: s, id: c._getFirstPointerId(t) }], this._changedPointerPositions = [
+      { x: i, y: s, id: c._getFirstPointerId(t) }
+    ]);
+  }
+  _setPointerPosition(t) {
+    c.warn('Method _setPointerPosition is deprecated. Use "stage.setPointersPositions(event)" instead.'), this.setPointersPositions(t);
+  }
+  _getContentPosition() {
+    if (!this.content || !this.content.getBoundingClientRect)
+      return {
+        top: 0,
+        left: 0,
+        scaleX: 1,
+        scaleY: 1
+      };
+    const t = this.content.getBoundingClientRect();
+    return {
+      top: t.top,
+      left: t.left,
+      scaleX: t.width / this.content.clientWidth || 1,
+      scaleY: t.height / this.content.clientHeight || 1
+    };
+  }
+  _buildDOM() {
+    if (this.bufferCanvas = new D({
+      width: this.width(),
+      height: this.height()
+    }), this.bufferHitCanvas = new Et({
+      pixelRatio: 1,
+      width: this.width(),
+      height: this.height()
+    }), !m.isBrowser)
+      return;
+    const t = this.container();
+    if (!t)
+      throw "Stage has no container. A container is required.";
+    t.innerHTML = "", this.content = document.createElement("div"), this.content.style.position = "relative", this.content.style.userSelect = "none", this.content.className = "konvajs-content", this.content.setAttribute("role", "presentation"), t.appendChild(this.content), this._resizeDOM();
+  }
+  cache() {
+    return c.warn("Cache function is not allowed for stage. You may use cache only for layers, groups and shapes."), this;
+  }
+  clearCache() {
+    return this;
+  }
+  batchDraw() {
+    return this.getChildren().forEach(function(t) {
+      t.batchDraw();
+    }), this;
+  }
+}
+gt.prototype.nodeType = ti;
+nt(gt);
+g.addGetterSetter(gt, "container");
+m.isBrowser && document.addEventListener("visibilitychange", () => {
+  Q.forEach((n) => {
+    n.batchDraw();
+  });
+});
+const re = "hasShadow", ae = "shadowRGBA", oe = "patternImage", he = "linearGradient", le = "radialGradient";
+let ct;
+function yt() {
+  return ct || (ct = c.createCanvasElement().getContext("2d"), ct);
+}
+const tt = {};
+function oi(n) {
+  const t = this.attrs.fillRule;
+  t ? n.fill(t) : n.fill();
+}
+function hi(n) {
+  n.stroke();
+}
+function li(n) {
+  const t = this.attrs.fillRule;
+  t ? n.fill(t) : n.fill();
+}
+function ci(n) {
+  n.stroke();
+}
+function di() {
+  this._clearCache(re);
+}
+function ui() {
+  this._clearCache(ae);
+}
+function fi() {
+  this._clearCache(oe);
+}
+function gi() {
+  this._clearCache(he);
+}
+function pi() {
+  this._clearCache(le);
+}
+class p extends _ {
+  constructor(t) {
+    super(t);
+    let e, i = 0;
+    for (; e = c.getHitColor(), !(e && !(e in tt)); )
+      if (i++, i >= 1e4) {
+        c.warn("Failed to find a unique color key for a shape. Konva may work incorrectly. Most likely your browser is using canvas farbling. Consider disabling it."), e = c.getRandomColor();
+        break;
+      }
+    this.colorKey = e, tt[e] = this;
+  }
+  getContext() {
+    return c.warn("shape.getContext() method is deprecated. Please do not use it."), this.getLayer().getContext();
+  }
+  getCanvas() {
+    return c.warn("shape.getCanvas() method is deprecated. Please do not use it."), this.getLayer().getCanvas();
+  }
+  getSceneFunc() {
+    return this.attrs.sceneFunc || this._sceneFunc;
+  }
+  getHitFunc() {
+    return this.attrs.hitFunc || this._hitFunc;
+  }
+  hasShadow() {
+    return this._getCache(re, this._hasShadow);
+  }
+  _hasShadow() {
+    return this.shadowEnabled() && this.shadowOpacity() !== 0 && !!(this.shadowColor() || this.shadowBlur() || this.shadowOffsetX() || this.shadowOffsetY());
+  }
+  _getFillPattern() {
+    return this._getCache(oe, this.__getFillPattern);
+  }
+  __getFillPattern() {
+    if (this.fillPatternImage()) {
+      const e = yt().createPattern(this.fillPatternImage(), this.fillPatternRepeat() || "repeat");
+      if (e && e.setTransform) {
+        const i = new L();
+        i.translate(this.fillPatternX(), this.fillPatternY()), i.rotate(m.getAngle(this.fillPatternRotation())), i.scale(this.fillPatternScaleX(), this.fillPatternScaleY()), i.translate(-1 * this.fillPatternOffsetX(), -1 * this.fillPatternOffsetY());
+        const s = i.getMatrix(), r = typeof DOMMatrix > "u" ? {
+          a: s[0],
+          b: s[1],
+          c: s[2],
+          d: s[3],
+          e: s[4],
+          f: s[5]
+        } : new DOMMatrix(s);
+        e.setTransform(r);
+      }
+      return e;
+    }
+  }
+  _getLinearGradient() {
+    return this._getCache(he, this.__getLinearGradient);
+  }
+  __getLinearGradient() {
+    const t = this.fillLinearGradientColorStops();
+    if (t) {
+      const e = yt(), i = this.fillLinearGradientStartPoint(), s = this.fillLinearGradientEndPoint(), r = e.createLinearGradient(i.x, i.y, s.x, s.y);
+      for (let a = 0; a < t.length; a += 2)
+        r.addColorStop(t[a], t[a + 1]);
+      return r;
+    }
+  }
+  _getRadialGradient() {
+    return this._getCache(le, this.__getRadialGradient);
+  }
+  __getRadialGradient() {
+    const t = this.fillRadialGradientColorStops();
+    if (t) {
+      const e = yt(), i = this.fillRadialGradientStartPoint(), s = this.fillRadialGradientEndPoint(), r = e.createRadialGradient(i.x, i.y, this.fillRadialGradientStartRadius(), s.x, s.y, this.fillRadialGradientEndRadius());
+      for (let a = 0; a < t.length; a += 2)
+        r.addColorStop(t[a], t[a + 1]);
+      return r;
+    }
+  }
+  getShadowRGBA() {
+    return this._getCache(ae, this._getShadowRGBA);
+  }
+  _getShadowRGBA() {
+    if (!this.hasShadow())
+      return;
+    const t = c.colorToRGBA(this.shadowColor());
+    if (t)
+      return "rgba(" + t.r + "," + t.g + "," + t.b + "," + t.a * (this.shadowOpacity() || 1) + ")";
+  }
+  hasFill() {
+    return this._calculate("hasFill", [
+      "fillEnabled",
+      "fill",
+      "fillPatternImage",
+      "fillLinearGradientColorStops",
+      "fillRadialGradientColorStops"
+    ], () => this.fillEnabled() && !!(this.fill() || this.fillPatternImage() || this.fillLinearGradientColorStops() || this.fillRadialGradientColorStops()));
+  }
+  hasStroke() {
+    return this._calculate("hasStroke", [
+      "strokeEnabled",
+      "strokeWidth",
+      "stroke",
+      "strokeLinearGradientColorStops"
+    ], () => this.strokeEnabled() && this.strokeWidth() && !!(this.stroke() || this.strokeLinearGradientColorStops()));
+  }
+  hasHitStroke() {
+    const t = this.hitStrokeWidth();
+    return t === "auto" ? this.hasStroke() : this.strokeEnabled() && !!t;
+  }
+  intersects(t) {
+    const e = this.getStage();
+    if (!e)
+      return !1;
+    const i = e.bufferHitCanvas;
+    return i.getContext().clear(), this.drawHit(i, void 0, !0), i.context.getImageData(Math.round(t.x), Math.round(t.y), 1, 1).data[3] > 0;
+  }
+  destroy() {
+    return _.prototype.destroy.call(this), delete tt[this.colorKey], delete this.colorKey, this;
+  }
+  _useBufferCanvas(t) {
+    var e;
+    if (!((e = this.attrs.perfectDrawEnabled) !== null && e !== void 0 ? e : !0))
+      return !1;
+    const s = t || this.hasFill(), r = this.hasStroke(), a = this.getAbsoluteOpacity() !== 1;
+    if (s && r && a)
+      return !0;
+    const o = this.hasShadow(), h = this.shadowForStrokeEnabled();
+    return !!(s && r && o && h);
+  }
+  setStrokeHitEnabled(t) {
+    c.warn("strokeHitEnabled property is deprecated. Please use hitStrokeWidth instead."), t ? this.hitStrokeWidth("auto") : this.hitStrokeWidth(0);
+  }
+  getStrokeHitEnabled() {
+    return this.hitStrokeWidth() !== 0;
+  }
+  getSelfRect() {
+    const t = this.size();
+    return {
+      x: this._centroid ? -t.width / 2 : 0,
+      y: this._centroid ? -t.height / 2 : 0,
+      width: t.width,
+      height: t.height
+    };
+  }
+  getClientRect(t = {}) {
+    let e = !1, i = this.getParent();
+    for (; i; ) {
+      if (i.isCached()) {
+        e = !0;
+        break;
+      }
+      i = i.getParent();
+    }
+    const s = t.skipTransform, r = t.relativeTo || e && this.getStage() || void 0, a = this.getSelfRect(), h = !t.skipStroke && this.hasStroke() && this.strokeWidth() || 0, l = a.width + h, d = a.height + h, u = !t.skipShadow && this.hasShadow(), f = u ? this.shadowOffsetX() : 0, C = u ? this.shadowOffsetY() : 0, y = l + Math.abs(f), P = d + Math.abs(C), E = u && this.shadowBlur() || 0, x = y + E * 2, A = P + E * 2, G = {
+      width: x,
+      height: A,
+      x: -(h / 2 + E) + Math.min(f, 0) + a.x,
+      y: -(h / 2 + E) + Math.min(C, 0) + a.y
+    };
+    return s ? G : this._transformedRect(G, r);
+  }
+  drawScene(t, e, i) {
+    const s = this.getLayer(), r = t || s.getCanvas(), a = r.getContext(), o = this._getCanvasCache(), h = this.getSceneFunc(), l = this.hasShadow();
+    let d;
+    const u = e === this;
+    if (!this.isVisible() && !u)
+      return this;
+    if (o) {
+      a.save();
+      const f = this.getAbsoluteTransform(e).getMatrix();
+      return a.transform(f[0], f[1], f[2], f[3], f[4], f[5]), this._drawCachedSceneCanvas(a), a.restore(), this;
+    }
+    if (!h)
+      return this;
+    if (a.save(), this._useBufferCanvas()) {
+      d = this.getStage();
+      const f = i || d.bufferCanvas, C = f.getContext();
+      i ? (C.save(), C.setTransform(1, 0, 0, 1, 0, 0), C.clearRect(0, 0, f.width, f.height), C.restore()) : C.clear(), C.save(), C._applyLineJoin(this), C._applyMiterLimit(this);
+      const y = this.getAbsoluteTransform(e).getMatrix();
+      C.transform(y[0], y[1], y[2], y[3], y[4], y[5]), h.call(this, C, this), C.restore();
+      const P = f.pixelRatio;
+      l && a._applyShadow(this), u || (a._applyOpacity(this), a._applyGlobalCompositeOperation(this)), a.drawImage(f._canvas, f.x || 0, f.y || 0, f.width / P, f.height / P);
+    } else {
+      if (a._applyLineJoin(this), a._applyMiterLimit(this), !u) {
+        const f = this.getAbsoluteTransform(e).getMatrix();
+        a.transform(f[0], f[1], f[2], f[3], f[4], f[5]), a._applyOpacity(this), a._applyGlobalCompositeOperation(this);
+      }
+      l && a._applyShadow(this), h.call(this, a, this);
+    }
+    return a.restore(), this;
+  }
+  drawHit(t, e, i = !1) {
+    if (!this.shouldDrawHit(e, i))
+      return this;
+    const s = this.getLayer(), r = t || s.hitCanvas, a = r && r.getContext(), o = this.hitFunc() || this.sceneFunc(), h = this._getCanvasCache(), l = h && h.hit;
+    if (this.colorKey || c.warn("Looks like your canvas has a destroyed shape in it. Do not reuse shape after you destroyed it. If you want to reuse shape you should call remove() instead of destroy()"), l) {
+      a.save();
+      const u = this.getAbsoluteTransform(e).getMatrix();
+      return a.transform(u[0], u[1], u[2], u[3], u[4], u[5]), this._drawCachedHitCanvas(a), a.restore(), this;
+    }
+    if (!o)
+      return this;
+    if (a.save(), a._applyLineJoin(this), a._applyMiterLimit(this), !(this === e)) {
+      const u = this.getAbsoluteTransform(e).getMatrix();
+      a.transform(u[0], u[1], u[2], u[3], u[4], u[5]);
+    }
+    return o.call(this, a, this), a.restore(), this;
+  }
+  drawHitFromCache(t = 0) {
+    const e = this._getCanvasCache(), i = this._getCachedSceneCanvas(), s = e.hit, r = s.getContext(), a = s.getWidth(), o = s.getHeight();
+    r.clear(), r.drawImage(i._canvas, 0, 0, a, o);
+    try {
+      const h = r.getImageData(0, 0, a, o), l = h.data, d = l.length, u = c._hexToRgb(this.colorKey);
+      for (let f = 0; f < d; f += 4)
+        l[f + 3] > t ? (l[f] = u.r, l[f + 1] = u.g, l[f + 2] = u.b, l[f + 3] = 255) : l[f + 3] = 0;
+      r.putImageData(h, 0, 0);
+    } catch (h) {
+      c.error("Unable to draw hit graph from cached scene canvas. " + h.message);
+    }
+    return this;
+  }
+  hasPointerCapture(t) {
+    return Kt(t, this);
+  }
+  setPointerCapture(t) {
+    qt(t, this);
+  }
+  releaseCapture(t) {
+    Z(t);
+  }
+}
+p.prototype._fillFunc = oi;
+p.prototype._strokeFunc = hi;
+p.prototype._fillFuncHit = li;
+p.prototype._strokeFuncHit = ci;
+p.prototype._centroid = !1;
+p.prototype.nodeType = "Shape";
+nt(p);
+p.prototype.eventListeners = {};
+p.prototype.on("shadowColorChange.konva shadowBlurChange.konva shadowOffsetChange.konva shadowOpacityChange.konva shadowEnabledChange.konva", di);
+p.prototype.on("shadowColorChange.konva shadowOpacityChange.konva shadowEnabledChange.konva", ui);
+p.prototype.on("fillPriorityChange.konva fillPatternImageChange.konva fillPatternRepeatChange.konva fillPatternScaleXChange.konva fillPatternScaleYChange.konva fillPatternOffsetXChange.konva fillPatternOffsetYChange.konva fillPatternXChange.konva fillPatternYChange.konva fillPatternRotationChange.konva", fi);
+p.prototype.on("fillPriorityChange.konva fillLinearGradientColorStopsChange.konva fillLinearGradientStartPointXChange.konva fillLinearGradientStartPointYChange.konva fillLinearGradientEndPointXChange.konva fillLinearGradientEndPointYChange.konva", gi);
+p.prototype.on("fillPriorityChange.konva fillRadialGradientColorStopsChange.konva fillRadialGradientStartPointXChange.konva fillRadialGradientStartPointYChange.konva fillRadialGradientEndPointXChange.konva fillRadialGradientEndPointYChange.konva fillRadialGradientStartRadiusChange.konva fillRadialGradientEndRadiusChange.konva", pi);
+g.addGetterSetter(p, "stroke", void 0, Wt());
+g.addGetterSetter(p, "strokeWidth", 2, b());
+g.addGetterSetter(p, "fillAfterStrokeEnabled", !1);
+g.addGetterSetter(p, "hitStrokeWidth", "auto", Ne());
+g.addGetterSetter(p, "strokeHitEnabled", !0, M());
+g.addGetterSetter(p, "perfectDrawEnabled", !0, M());
+g.addGetterSetter(p, "shadowForStrokeEnabled", !0, M());
+g.addGetterSetter(p, "lineJoin");
+g.addGetterSetter(p, "lineCap");
+g.addGetterSetter(p, "miterLimit");
+g.addGetterSetter(p, "sceneFunc");
+g.addGetterSetter(p, "hitFunc");
+g.addGetterSetter(p, "dash");
+g.addGetterSetter(p, "dashOffset", 0, b());
+g.addGetterSetter(p, "shadowColor", void 0, Y());
+g.addGetterSetter(p, "shadowBlur", 0, b());
+g.addGetterSetter(p, "shadowOpacity", 1, b());
+g.addComponentsGetterSetter(p, "shadowOffset", ["x", "y"]);
+g.addGetterSetter(p, "shadowOffsetX", 0, b());
+g.addGetterSetter(p, "shadowOffsetY", 0, b());
+g.addGetterSetter(p, "fillPatternImage");
+g.addGetterSetter(p, "fill", void 0, Wt());
+g.addGetterSetter(p, "fillPatternX", 0, b());
+g.addGetterSetter(p, "fillPatternY", 0, b());
+g.addGetterSetter(p, "fillLinearGradientColorStops");
+g.addGetterSetter(p, "strokeLinearGradientColorStops");
+g.addGetterSetter(p, "fillRadialGradientStartRadius", 0);
+g.addGetterSetter(p, "fillRadialGradientEndRadius", 0);
+g.addGetterSetter(p, "fillRadialGradientColorStops");
+g.addGetterSetter(p, "fillPatternRepeat", "repeat");
+g.addGetterSetter(p, "fillEnabled", !0);
+g.addGetterSetter(p, "strokeEnabled", !0);
+g.addGetterSetter(p, "shadowEnabled", !0);
+g.addGetterSetter(p, "dashEnabled", !0);
+g.addGetterSetter(p, "strokeScaleEnabled", !0);
+g.addGetterSetter(p, "fillPriority", "color");
+g.addComponentsGetterSetter(p, "fillPatternOffset", ["x", "y"]);
+g.addGetterSetter(p, "fillPatternOffsetX", 0, b());
+g.addGetterSetter(p, "fillPatternOffsetY", 0, b());
+g.addComponentsGetterSetter(p, "fillPatternScale", ["x", "y"]);
+g.addGetterSetter(p, "fillPatternScaleX", 1, b());
+g.addGetterSetter(p, "fillPatternScaleY", 1, b());
+g.addComponentsGetterSetter(p, "fillLinearGradientStartPoint", [
+  "x",
+  "y"
+]);
+g.addComponentsGetterSetter(p, "strokeLinearGradientStartPoint", [
+  "x",
+  "y"
+]);
+g.addGetterSetter(p, "fillLinearGradientStartPointX", 0);
+g.addGetterSetter(p, "strokeLinearGradientStartPointX", 0);
+g.addGetterSetter(p, "fillLinearGradientStartPointY", 0);
+g.addGetterSetter(p, "strokeLinearGradientStartPointY", 0);
+g.addComponentsGetterSetter(p, "fillLinearGradientEndPoint", [
+  "x",
+  "y"
+]);
+g.addComponentsGetterSetter(p, "strokeLinearGradientEndPoint", [
+  "x",
+  "y"
+]);
+g.addGetterSetter(p, "fillLinearGradientEndPointX", 0);
+g.addGetterSetter(p, "strokeLinearGradientEndPointX", 0);
+g.addGetterSetter(p, "fillLinearGradientEndPointY", 0);
+g.addGetterSetter(p, "strokeLinearGradientEndPointY", 0);
+g.addComponentsGetterSetter(p, "fillRadialGradientStartPoint", [
+  "x",
+  "y"
+]);
+g.addGetterSetter(p, "fillRadialGradientStartPointX", 0);
+g.addGetterSetter(p, "fillRadialGradientStartPointY", 0);
+g.addComponentsGetterSetter(p, "fillRadialGradientEndPoint", [
+  "x",
+  "y"
+]);
+g.addGetterSetter(p, "fillRadialGradientEndPointX", 0);
+g.addGetterSetter(p, "fillRadialGradientEndPointY", 0);
+g.addGetterSetter(p, "fillPatternRotation", 0);
+g.addGetterSetter(p, "fillRule", void 0, Y());
+g.backCompat(p, {
+  dashArray: "dash",
+  getDashArray: "getDash",
+  setDashArray: "getDash",
+  drawFunc: "sceneFunc",
+  getDrawFunc: "getSceneFunc",
+  setDrawFunc: "setSceneFunc",
+  drawHitFunc: "hitFunc",
+  getDrawHitFunc: "getHitFunc",
+  setDrawHitFunc: "setHitFunc"
+});
+const mi = "beforeDraw", _i = "draw", ce = [
+  { x: 0, y: 0 },
+  { x: -1, y: -1 },
+  { x: 1, y: -1 },
+  { x: 1, y: 1 },
+  { x: -1, y: 1 }
+], yi = ce.length;
+class N extends k {
+  constructor(t) {
+    super(t), this.canvas = new D(), this.hitCanvas = new Et({
+      pixelRatio: 1
+    }), this._waitingForDraw = !1, this.on("visibleChange.konva", this._checkVisibility), this._checkVisibility(), this.on("imageSmoothingEnabledChange.konva", this._setSmoothEnabled), this._setSmoothEnabled();
+  }
+  createPNGStream() {
+    return this.canvas._canvas.createPNGStream();
+  }
+  getCanvas() {
+    return this.canvas;
+  }
+  getNativeCanvasElement() {
+    return this.canvas._canvas;
+  }
+  getHitCanvas() {
+    return this.hitCanvas;
+  }
+  getContext() {
+    return this.getCanvas().getContext();
+  }
+  clear(t) {
+    return this.getContext().clear(t), this.getHitCanvas().getContext().clear(t), this;
+  }
+  setZIndex(t) {
+    super.setZIndex(t);
+    const e = this.getStage();
+    return e && e.content && (e.content.removeChild(this.getNativeCanvasElement()), t < e.children.length - 1 ? e.content.insertBefore(this.getNativeCanvasElement(), e.children[t + 1].getCanvas()._canvas) : e.content.appendChild(this.getNativeCanvasElement())), this;
+  }
+  moveToTop() {
+    _.prototype.moveToTop.call(this);
+    const t = this.getStage();
+    return t && t.content && (t.content.removeChild(this.getNativeCanvasElement()), t.content.appendChild(this.getNativeCanvasElement())), !0;
+  }
+  moveUp() {
+    if (!_.prototype.moveUp.call(this))
+      return !1;
+    const e = this.getStage();
+    return !e || !e.content ? !1 : (e.content.removeChild(this.getNativeCanvasElement()), this.index < e.children.length - 1 ? e.content.insertBefore(this.getNativeCanvasElement(), e.children[this.index + 1].getCanvas()._canvas) : e.content.appendChild(this.getNativeCanvasElement()), !0);
+  }
+  moveDown() {
+    if (_.prototype.moveDown.call(this)) {
+      const t = this.getStage();
+      if (t) {
+        const e = t.children;
+        t.content && (t.content.removeChild(this.getNativeCanvasElement()), t.content.insertBefore(this.getNativeCanvasElement(), e[this.index + 1].getCanvas()._canvas));
+      }
+      return !0;
+    }
+    return !1;
+  }
+  moveToBottom() {
+    if (_.prototype.moveToBottom.call(this)) {
+      const t = this.getStage();
+      if (t) {
+        const e = t.children;
+        t.content && (t.content.removeChild(this.getNativeCanvasElement()), t.content.insertBefore(this.getNativeCanvasElement(), e[1].getCanvas()._canvas));
+      }
+      return !0;
+    }
+    return !1;
+  }
+  getLayer() {
+    return this;
+  }
+  remove() {
+    const t = this.getNativeCanvasElement();
+    return _.prototype.remove.call(this), t && t.parentNode && c._isInDocument(t) && t.parentNode.removeChild(t), this;
+  }
+  getStage() {
+    return this.parent;
+  }
+  setSize({ width: t, height: e }) {
+    return this.canvas.setSize(t, e), this.hitCanvas.setSize(t, e), this._setSmoothEnabled(), this;
+  }
+  _validateAdd(t) {
+    const e = t.getType();
+    e !== "Group" && e !== "Shape" && c.throw("You may only add groups and shapes to a layer.");
+  }
+  _toKonvaCanvas(t) {
+    return t = { ...t }, t.width = t.width || this.getWidth(), t.height = t.height || this.getHeight(), t.x = t.x !== void 0 ? t.x : this.x(), t.y = t.y !== void 0 ? t.y : this.y(), _.prototype._toKonvaCanvas.call(this, t);
+  }
+  _checkVisibility() {
+    this.visible() ? this.canvas._canvas.style.display = "block" : this.canvas._canvas.style.display = "none";
+  }
+  _setSmoothEnabled() {
+    this.getContext()._context.imageSmoothingEnabled = this.imageSmoothingEnabled();
+  }
+  getWidth() {
+    if (this.parent)
+      return this.parent.width();
+  }
+  setWidth() {
+    c.warn('Can not change width of layer. Use "stage.width(value)" function instead.');
+  }
+  getHeight() {
+    if (this.parent)
+      return this.parent.height();
+  }
+  setHeight() {
+    c.warn('Can not change height of layer. Use "stage.height(value)" function instead.');
+  }
+  batchDraw() {
+    return this._waitingForDraw || (this._waitingForDraw = !0, c.requestAnimFrame(() => {
+      this.draw(), this._waitingForDraw = !1;
+    })), this;
+  }
+  getIntersection(t) {
+    if (!this.isListening() || !this.isVisible())
+      return null;
+    let e = 1, i = !1;
+    for (; ; ) {
+      for (let s = 0; s < yi; s++) {
+        const r = ce[s], a = this._getIntersection({
+          x: t.x + r.x * e,
+          y: t.y + r.y * e
+        }), o = a.shape;
+        if (o)
+          return o;
+        if (i = !!a.antialiased, !a.antialiased)
+          break;
+      }
+      if (i)
+        e += 1;
+      else
+        return null;
+    }
+  }
+  _getIntersection(t) {
+    const e = this.hitCanvas.pixelRatio, i = this.hitCanvas.context.getImageData(Math.round(t.x * e), Math.round(t.y * e), 1, 1).data, s = i[3];
+    if (s === 255) {
+      const r = c.getHitColorKey(i[0], i[1], i[2]), a = tt[r];
+      return a ? {
+        shape: a
+      } : {
+        antialiased: !0
+      };
+    } else if (s > 0)
+      return {
+        antialiased: !0
+      };
+    return {};
+  }
+  drawScene(t, e, i) {
+    const s = this.getLayer(), r = t || s && s.getCanvas();
+    return this._fire(mi, {
+      node: this
+    }), this.clearBeforeDraw() && r.getContext().clear(), k.prototype.drawScene.call(this, r, e, i), this._fire(_i, {
+      node: this
+    }), this;
+  }
+  drawHit(t, e) {
+    const i = this.getLayer(), s = t || i && i.hitCanvas;
+    return i && i.clearBeforeDraw() && i.getHitCanvas().getContext().clear(), k.prototype.drawHit.call(this, s, e), this;
+  }
+  enableHitGraph() {
+    return this.hitGraphEnabled(!0), this;
+  }
+  disableHitGraph() {
+    return this.hitGraphEnabled(!1), this;
+  }
+  setHitGraphEnabled(t) {
+    c.warn("hitGraphEnabled method is deprecated. Please use layer.listening() instead."), this.listening(t);
+  }
+  getHitGraphEnabled(t) {
+    return c.warn("hitGraphEnabled method is deprecated. Please use layer.listening() instead."), this.listening();
+  }
+  toggleHitCanvas() {
+    if (!this.parent || !this.parent.content)
+      return;
+    const t = this.parent;
+    !!this.hitCanvas._canvas.parentNode ? t.content.removeChild(this.hitCanvas._canvas) : t.content.appendChild(this.hitCanvas._canvas);
+  }
+  destroy() {
+    return c.releaseCanvas(this.getNativeCanvasElement(), this.getHitCanvas()._canvas), super.destroy();
+  }
+}
+N.prototype.nodeType = "Layer";
+nt(N);
+g.addGetterSetter(N, "imageSmoothingEnabled", !0);
+g.addGetterSetter(N, "clearBeforeDraw", !0);
+g.addGetterSetter(N, "hitGraphEnabled", !0, M());
+class kt extends N {
+  constructor(t) {
+    super(t), this.listening(!1), c.warn('Konva.Fast layer is deprecated. Please use "new Konva.Layer({ listening: false })" instead.');
+  }
+}
+kt.prototype.nodeType = "FastLayer";
+nt(kt);
+class Rt extends k {
+  _validateAdd(t) {
+    const e = t.getType();
+    e !== "Group" && e !== "Shape" && c.throw("You may only add groups and shapes to groups.");
+  }
+}
+Rt.prototype.nodeType = "Group";
+nt(Rt);
+const Ct = (function() {
+  return B.performance && B.performance.now ? function() {
+    return B.performance.now();
+  } : function() {
+    return (/* @__PURE__ */ new Date()).getTime();
+  };
+})();
+class R {
+  constructor(t, e) {
+    this.id = R.animIdCounter++, this.frame = {
+      time: 0,
+      timeDiff: 0,
+      lastTime: Ct(),
+      frameRate: 0
+    }, this.func = t, this.setLayers(e);
+  }
+  setLayers(t) {
+    let e = [];
+    return t && (e = Array.isArray(t) ? t : [t]), this.layers = e, this;
+  }
+  getLayers() {
+    return this.layers;
+  }
+  addLayer(t) {
+    const e = this.layers, i = e.length;
+    for (let s = 0; s < i; s++)
+      if (e[s]._id === t._id)
+        return !1;
+    return this.layers.push(t), !0;
+  }
+  isRunning() {
+    const e = R.animations, i = e.length;
+    for (let s = 0; s < i; s++)
+      if (e[s].id === this.id)
+        return !0;
+    return !1;
+  }
+  start() {
+    return this.stop(), this.frame.timeDiff = 0, this.frame.lastTime = Ct(), R._addAnimation(this), this;
+  }
+  stop() {
+    return R._removeAnimation(this), this;
+  }
+  _updateFrameObject(t) {
+    this.frame.timeDiff = t - this.frame.lastTime, this.frame.lastTime = t, this.frame.time += this.frame.timeDiff, this.frame.frameRate = 1e3 / this.frame.timeDiff;
+  }
+  static _addAnimation(t) {
+    this.animations.push(t), this._handleAnimation();
+  }
+  static _removeAnimation(t) {
+    const e = t.id, i = this.animations, s = i.length;
+    for (let r = 0; r < s; r++)
+      if (i[r].id === e) {
+        this.animations.splice(r, 1);
+        break;
+      }
+  }
+  static _runFrames() {
+    const t = {}, e = this.animations;
+    for (let i = 0; i < e.length; i++) {
+      const s = e[i], r = s.layers, a = s.func;
+      s._updateFrameObject(Ct());
+      const o = r.length;
+      let h;
+      if (a ? h = a.call(s, s.frame) !== !1 : h = !0, !!h)
+        for (let l = 0; l < o; l++) {
+          const d = r[l];
+          d._id !== void 0 && (t[d._id] = d);
+        }
+    }
+    for (const i in t)
+      t.hasOwnProperty(i) && t[i].batchDraw();
+  }
+  static _animationLoop() {
+    const t = R;
+    t.animations.length ? (t._runFrames(), c.requestAnimFrame(t._animationLoop)) : t.animRunning = !1;
+  }
+  static _handleAnimation() {
+    this.animRunning || (this.animRunning = !0, c.requestAnimFrame(this._animationLoop));
+  }
+}
+R.animations = [];
+R.animIdCounter = 0;
+R.animRunning = !1;
+const Ci = {
+  node: 1,
+  duration: 1,
+  easing: 1,
+  onFinish: 1,
+  yoyo: 1
+}, vi = 1, Yt = 2, Xt = 3, Vt = ["fill", "stroke", "shadowColor"];
+let bi = 0;
+class Si {
+  constructor(t, e, i, s, r, a, o) {
+    this.prop = t, this.propFunc = e, this.begin = s, this._pos = s, this.duration = a, this._change = 0, this.prevPos = 0, this.yoyo = o, this._time = 0, this._position = 0, this._startTime = 0, this._finish = 0, this.func = i, this._change = r - this.begin, this.pause();
+  }
+  fire(t) {
+    const e = this[t];
+    e && e();
+  }
+  setTime(t) {
+    t > this.duration ? this.yoyo ? (this._time = this.duration, this.reverse()) : this.finish() : t < 0 ? this.yoyo ? (this._time = 0, this.play()) : this.reset() : (this._time = t, this.update());
+  }
+  getTime() {
+    return this._time;
+  }
+  setPosition(t) {
+    this.prevPos = this._pos, this.propFunc(t), this._pos = t;
+  }
+  getPosition(t) {
+    return t === void 0 && (t = this._time), this.func(t, this.begin, this._change, this.duration);
+  }
+  play() {
+    this.state = Yt, this._startTime = this.getTimer() - this._time, this.onEnterFrame(), this.fire("onPlay");
+  }
+  reverse() {
+    this.state = Xt, this._time = this.duration - this._time, this._startTime = this.getTimer() - this._time, this.onEnterFrame(), this.fire("onReverse");
+  }
+  seek(t) {
+    this.pause(), this._time = t, this.update(), this.fire("onSeek");
+  }
+  reset() {
+    this.pause(), this._time = 0, this.update(), this.fire("onReset");
+  }
+  finish() {
+    this.pause(), this._time = this.duration, this.update(), this.fire("onFinish");
+  }
+  update() {
+    this.setPosition(this.getPosition(this._time)), this.fire("onUpdate");
+  }
+  onEnterFrame() {
+    const t = this.getTimer() - this._startTime;
+    this.state === Yt ? this.setTime(t) : this.state === Xt && this.setTime(this.duration - t);
+  }
+  pause() {
+    this.state = vi, this.fire("onPause");
+  }
+  getTimer() {
+    return (/* @__PURE__ */ new Date()).getTime();
+  }
+}
+class w {
+  constructor(t) {
+    const e = this, i = t.node, s = i._id, r = t.easing || et.Linear, a = !!t.yoyo;
+    let o, h;
+    typeof t.duration > "u" ? o = 0.3 : t.duration === 0 ? o = 1e-3 : o = t.duration, this.node = i, this._id = bi++;
+    const l = i.getLayer() || (i instanceof m.Stage ? i.getLayers() : null);
+    l || c.error("Tween constructor have `node` that is not in a layer. Please add node into layer first."), this.anim = new R(function() {
+      e.tween.onEnterFrame();
+    }, l), this.tween = new Si(h, function(d) {
+      e._tweenFunc(d);
+    }, r, 0, 1, o * 1e3, a), this._addListeners(), w.attrs[s] || (w.attrs[s] = {}), w.attrs[s][this._id] || (w.attrs[s][this._id] = {}), w.tweens[s] || (w.tweens[s] = {});
+    for (h in t)
+      Ci[h] === void 0 && this._addAttr(h, t[h]);
+    this.reset(), this.onFinish = t.onFinish, this.onReset = t.onReset, this.onUpdate = t.onUpdate;
+  }
+  _addAttr(t, e) {
+    const i = this.node, s = i._id;
+    let r, a, o, h, l;
+    const d = w.tweens[s][t];
+    d && delete w.attrs[s][d][t];
+    let u = i.getAttr(t);
+    if (c._isArray(e))
+      if (r = [], a = Math.max(e.length, u.length), t === "points" && e.length !== u.length && (e.length > u.length ? (h = u, u = c._prepareArrayForTween(u, e, i.closed())) : (o = e, e = c._prepareArrayForTween(e, u, i.closed()))), t.indexOf("fill") === 0)
+        for (let f = 0; f < a; f++)
+          if (f % 2 === 0)
+            r.push(e[f] - u[f]);
+          else {
+            const C = c.colorToRGBA(u[f]);
+            l = c.colorToRGBA(e[f]), u[f] = C, r.push({
+              r: l.r - C.r,
+              g: l.g - C.g,
+              b: l.b - C.b,
+              a: l.a - C.a
+            });
+          }
+      else
+        for (let f = 0; f < a; f++)
+          r.push(e[f] - u[f]);
+    else Vt.indexOf(t) !== -1 ? (u = c.colorToRGBA(u), l = c.colorToRGBA(e), r = {
+      r: l.r - u.r,
+      g: l.g - u.g,
+      b: l.b - u.b,
+      a: l.a - u.a
+    }) : r = e - u;
+    w.attrs[s][this._id][t] = {
+      start: u,
+      diff: r,
+      end: e,
+      trueEnd: o,
+      trueStart: h
+    }, w.tweens[s][t] = this._id;
+  }
+  _tweenFunc(t) {
+    const e = this.node, i = w.attrs[e._id][this._id];
+    let s, r, a, o, h, l, d, u;
+    for (s in i) {
+      if (r = i[s], a = r.start, o = r.diff, u = r.end, c._isArray(a))
+        if (h = [], d = Math.max(a.length, u.length), s.indexOf("fill") === 0)
+          for (l = 0; l < d; l++)
+            l % 2 === 0 ? h.push((a[l] || 0) + o[l] * t) : h.push("rgba(" + Math.round(a[l].r + o[l].r * t) + "," + Math.round(a[l].g + o[l].g * t) + "," + Math.round(a[l].b + o[l].b * t) + "," + (a[l].a + o[l].a * t) + ")");
+        else
+          for (l = 0; l < d; l++)
+            h.push((a[l] || 0) + o[l] * t);
+      else Vt.indexOf(s) !== -1 ? h = "rgba(" + Math.round(a.r + o.r * t) + "," + Math.round(a.g + o.g * t) + "," + Math.round(a.b + o.b * t) + "," + (a.a + o.a * t) + ")" : h = a + o * t;
+      e.setAttr(s, h);
+    }
+  }
+  _addListeners() {
+    this.tween.onPlay = () => {
+      this.anim.start();
+    }, this.tween.onReverse = () => {
+      this.anim.start();
+    }, this.tween.onPause = () => {
+      this.anim.stop();
+    }, this.tween.onFinish = () => {
+      const t = this.node, e = w.attrs[t._id][this._id];
+      e.points && e.points.trueEnd && t.setAttr("points", e.points.trueEnd), this.onFinish && this.onFinish.call(this);
+    }, this.tween.onReset = () => {
+      const t = this.node, e = w.attrs[t._id][this._id];
+      e.points && e.points.trueStart && t.points(e.points.trueStart), this.onReset && this.onReset();
+    }, this.tween.onUpdate = () => {
+      this.onUpdate && this.onUpdate.call(this);
+    };
+  }
+  play() {
+    return this.tween.play(), this;
+  }
+  reverse() {
+    return this.tween.reverse(), this;
+  }
+  reset() {
+    return this.tween.reset(), this;
+  }
+  seek(t) {
+    return this.tween.seek(t * 1e3), this;
+  }
+  pause() {
+    return this.tween.pause(), this;
+  }
+  finish() {
+    return this.tween.finish(), this;
+  }
+  destroy() {
+    const t = this.node._id, e = this._id, i = w.tweens[t];
+    this.pause(), this.anim && this.anim.stop();
+    for (const s in i)
+      delete w.tweens[t][s];
+    delete w.attrs[t][e], w.tweens[t] && (Object.keys(w.tweens[t]).length === 0 && delete w.tweens[t], Object.keys(w.attrs[t]).length === 0 && delete w.attrs[t]);
+  }
+}
+w.attrs = {};
+w.tweens = {};
+_.prototype.to = function(n) {
+  const t = n.onFinish;
+  n.node = this, n.onFinish = function() {
+    this.destroy(), t && t();
+  }, new w(n).play();
+};
+const et = {
+  BackEaseIn(n, t, e, i) {
+    return e * (n /= i) * n * ((1.70158 + 1) * n - 1.70158) + t;
+  },
+  BackEaseOut(n, t, e, i) {
+    return e * ((n = n / i - 1) * n * ((1.70158 + 1) * n + 1.70158) + 1) + t;
+  },
+  BackEaseInOut(n, t, e, i) {
+    let s = 1.70158;
+    return (n /= i / 2) < 1 ? e / 2 * (n * n * (((s *= 1.525) + 1) * n - s)) + t : e / 2 * ((n -= 2) * n * (((s *= 1.525) + 1) * n + s) + 2) + t;
+  },
+  ElasticEaseIn(n, t, e, i, s, r) {
+    let a = 0;
+    return n === 0 ? t : (n /= i) === 1 ? t + e : (r || (r = i * 0.3), !s || s < Math.abs(e) ? (s = e, a = r / 4) : a = r / (2 * Math.PI) * Math.asin(e / s), -(s * Math.pow(2, 10 * (n -= 1)) * Math.sin((n * i - a) * (2 * Math.PI) / r)) + t);
+  },
+  ElasticEaseOut(n, t, e, i, s, r) {
+    let a = 0;
+    return n === 0 ? t : (n /= i) === 1 ? t + e : (r || (r = i * 0.3), !s || s < Math.abs(e) ? (s = e, a = r / 4) : a = r / (2 * Math.PI) * Math.asin(e / s), s * Math.pow(2, -10 * n) * Math.sin((n * i - a) * (2 * Math.PI) / r) + e + t);
+  },
+  ElasticEaseInOut(n, t, e, i, s, r) {
+    let a = 0;
+    return n === 0 ? t : (n /= i / 2) === 2 ? t + e : (r || (r = i * (0.3 * 1.5)), !s || s < Math.abs(e) ? (s = e, a = r / 4) : a = r / (2 * Math.PI) * Math.asin(e / s), n < 1 ? -0.5 * (s * Math.pow(2, 10 * (n -= 1)) * Math.sin((n * i - a) * (2 * Math.PI) / r)) + t : s * Math.pow(2, -10 * (n -= 1)) * Math.sin((n * i - a) * (2 * Math.PI) / r) * 0.5 + e + t);
+  },
+  BounceEaseOut(n, t, e, i) {
+    return (n /= i) < 1 / 2.75 ? e * (7.5625 * n * n) + t : n < 2 / 2.75 ? e * (7.5625 * (n -= 1.5 / 2.75) * n + 0.75) + t : n < 2.5 / 2.75 ? e * (7.5625 * (n -= 2.25 / 2.75) * n + 0.9375) + t : e * (7.5625 * (n -= 2.625 / 2.75) * n + 0.984375) + t;
+  },
+  BounceEaseIn(n, t, e, i) {
+    return e - et.BounceEaseOut(i - n, 0, e, i) + t;
+  },
+  BounceEaseInOut(n, t, e, i) {
+    return n < i / 2 ? et.BounceEaseIn(n * 2, 0, e, i) * 0.5 + t : et.BounceEaseOut(n * 2 - i, 0, e, i) * 0.5 + e * 0.5 + t;
+  },
+  EaseIn(n, t, e, i) {
+    return e * (n /= i) * n + t;
+  },
+  EaseOut(n, t, e, i) {
+    return -e * (n /= i) * (n - 2) + t;
+  },
+  EaseInOut(n, t, e, i) {
+    return (n /= i / 2) < 1 ? e / 2 * n * n + t : -e / 2 * (--n * (n - 2) - 1) + t;
+  },
+  StrongEaseIn(n, t, e, i) {
+    return e * (n /= i) * n * n * n * n + t;
+  },
+  StrongEaseOut(n, t, e, i) {
+    return e * ((n = n / i - 1) * n * n * n * n + 1) + t;
+  },
+  StrongEaseInOut(n, t, e, i) {
+    return (n /= i / 2) < 1 ? e / 2 * n * n * n * n * n + t : e / 2 * ((n -= 2) * n * n * n * n + 2) + t;
+  },
+  Linear(n, t, e, i) {
+    return e * n / i + t;
+  }
+}, Pi = c._assign(m, {
+  Util: c,
+  Transform: L,
+  Node: _,
+  Container: k,
+  Stage: gt,
+  stages: Q,
+  Layer: N,
+  FastLayer: kt,
+  Group: Rt,
+  DD: v,
+  Shape: p,
+  shapes: tt,
+  Animation: R,
+  Tween: w,
+  Easings: et,
+  Context: ft,
+  Canvas: xt
+});
+export {
+  R as A,
+  g as F,
+  Rt as G,
+  m as K,
+  _ as N,
+  wi as R,
+  p as S,
+  L as T,
+  c as U,
+  nt as _,
+  M as a,
+  Ei as b,
+  xi as c,
+  Ne as d,
+  Y as e,
+  Pi as f,
+  b as g
+};