@nightshadeui/canvas 2.11.0

package/dist/canvas.mjs

@@ -0,0 +1,2171 @@
+import { openBlock as V, createElementBlock as q, createElementVNode as j, normalizeStyle as Z, createCommentVNode as Pt, withModifiers as U, normalizeClass as _t, resolveComponent as oe, renderSlot as re, normalizeProps as jt, guardReactiveProps as Ct, Fragment as Et, renderList as It, createBlock as Xe, createVNode as K, withCtx as G, toDisplayString as X, reactive as Tt } from "vue";
+const te = (o, e) => {
+  const t = o.__vccOpts || o;
+  for (const [n, r] of e)
+    t[n] = r;
+  return t;
+}, zt = {
+  props: {
+    canvas: { type: Object, required: !0 }
+  }
+}, Dt = {
+  key: 0,
+  class: "CanvasBoxSelect"
+};
+function Rt(o, e, t, n, r, c) {
+  return t.canvas.boxSelect.isSelecting() ? (V(), q("div", Dt, [
+    j("div", {
+      class: "Box",
+      style: Z(t.canvas.boxSelect.getSelectionStyle())
+    }, null, 4)
+  ])) : Pt("", !0);
+}
+const kt = /* @__PURE__ */ te(zt, [["render", Rt], ["__scopeId", "data-v-9e8905e1"]]);
+function z(o, e, t) {
+  return Math.max(e, Math.min(t, o));
+}
+function We(o, e) {
+  return {
+    x: o.x - e.x,
+    y: o.y - e.y
+  };
+}
+function ie(o, e) {
+  const t = { x: Math.min(o.x, e.x), y: Math.min(o.y, e.y) }, n = { x: Math.max(o.x, e.x), y: Math.max(o.y, e.y) };
+  return [t, n];
+}
+function Le(o, e) {
+  const t = o[1].x >= e[0].x && e[1].x >= o[0].x, n = o[1].y >= e[0].y && e[1].y >= o[0].y;
+  return t && n;
+}
+function Bt(o) {
+  const [e, t] = o;
+  return {
+    x: (t.x - e.x) * 0.5 + e.x,
+    y: (t.y - e.y) * 0.5 + e.y
+  };
+}
+function Ze(o, e, t) {
+  const n = o ?? document.documentElement;
+  return getComputedStyle(n).getPropertyValue(e).trim() || t;
+}
+function W(o, e, t) {
+  const n = Ze(o, e, String(t)), r = Number(n.replace(/px|em|%|vh|vw/g, ""));
+  return Number.isFinite(r) ? r : t;
+}
+function $e(o, e, t) {
+  const n = o ?? document.documentElement, r = Ze(o, e, t), c = document.createElement("span");
+  c.style.position = "absolute", c.style.visibility = "hidden", c.style.pointerEvents = "none", c.style.color = t, c.style.color = r, n.appendChild(c);
+  const p = getComputedStyle(c).color.trim();
+  return c.remove(), p || t;
+}
+class ue {
+  constructor(e) {
+    this.target = e, this.entries = [];
+  }
+  add(e, t, n) {
+    this.target.addEventListener(e, t, n), this.entries.push({ type: e, listener: t, options: n });
+  }
+  removeAll() {
+    for (const e of this.entries)
+      this.target.removeEventListener(e.type, e.listener, e.options);
+    this.entries = [];
+  }
+}
+function Ut(o, e, t, n = 2, r, c = 1) {
+  const p = [0, ...Vt(o, e), o], y = [0, o], S = [
+    `<svg xmlns="http://www.w3.org/2000/svg"
+        width="${o}"
+        height="${o}"
+        viewBox="0 0 ${o} ${o}">`
+  ];
+  if (c)
+    for (const C of p)
+      for (const E of p)
+        S.push(
+          `<circle cx="${C}" cy="${E}" r="${c}" fill="${r}"/>`
+        );
+  if (n)
+    for (const C of y)
+      for (const E of y)
+        S.push(
+          `<circle cx="${C}" cy="${E}" r="${n}" fill="${t}"/>`
+        );
+  return S.push("</svg>"), S.join("");
+}
+function Vt(o, e) {
+  const t = [], n = Math.round(o / e);
+  for (let r = 1; r < e; r++)
+    t.push(n * r);
+  return t;
+}
+var Ae = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Ge = {};
+var Fe;
+function Lt() {
+  if (Fe) return Ge;
+  Fe = 1;
+  var o;
+  return (function(e) {
+    (function(t) {
+      var n = typeof globalThis == "object" ? globalThis : typeof Ae == "object" ? Ae : typeof self == "object" ? self : typeof this == "object" ? this : S(), r = c(e);
+      typeof n.Reflect < "u" && (r = c(n.Reflect, r)), t(r, n), typeof n.Reflect > "u" && (n.Reflect = e);
+      function c(C, E) {
+        return function(R, N) {
+          Object.defineProperty(C, R, { configurable: !0, writable: !0, value: N }), E && E(R, N);
+        };
+      }
+      function p() {
+        try {
+          return Function("return this;")();
+        } catch {
+        }
+      }
+      function y() {
+        try {
+          return (0, eval)("(function() { return this; })()");
+        } catch {
+        }
+      }
+      function S() {
+        return p() || y();
+      }
+    })(function(t, n) {
+      var r = Object.prototype.hasOwnProperty, c = typeof Symbol == "function", p = c && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", y = c && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", S = typeof Object.create == "function", C = { __proto__: [] } instanceof Array, E = !S && !C, R = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: S ? function() {
+          return ge(/* @__PURE__ */ Object.create(null));
+        } : C ? function() {
+          return ge({ __proto__: null });
+        } : function() {
+          return ge({});
+        },
+        has: E ? function(s, i) {
+          return r.call(s, i);
+        } : function(s, i) {
+          return i in s;
+        },
+        get: E ? function(s, i) {
+          return r.call(s, i) ? s[i] : void 0;
+        } : function(s, i) {
+          return s[i];
+        }
+      }, N = Object.getPrototypeOf(Function), Y = typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : bt(), de = typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : xt(), fe = typeof WeakMap == "function" ? WeakMap : St(), $ = c ? /* @__PURE__ */ Symbol.for("@reflect-metadata:registry") : void 0, se = gt(), Se = wt(se);
+      function Qe(s, i, a, l) {
+        if (g(a)) {
+          if (!Te(s))
+            throw new TypeError();
+          if (!ze(i))
+            throw new TypeError();
+          return lt(s, i);
+        } else {
+          if (!Te(s))
+            throw new TypeError();
+          if (!O(i))
+            throw new TypeError();
+          if (!O(l) && !g(l) && !A(l))
+            throw new TypeError();
+          return A(l) && (l = void 0), a = T(a), ut(s, i, a, l);
+        }
+      }
+      t("decorate", Qe);
+      function et(s, i) {
+        function a(l, v) {
+          if (!O(l))
+            throw new TypeError();
+          if (!g(v) && !pt(v))
+            throw new TypeError();
+          _e(s, i, l, v);
+        }
+        return a;
+      }
+      t("metadata", et);
+      function tt(s, i, a, l) {
+        if (!O(a))
+          throw new TypeError();
+        return g(l) || (l = T(l)), _e(s, i, a, l);
+      }
+      t("defineMetadata", tt);
+      function st(s, i, a) {
+        if (!O(i))
+          throw new TypeError();
+        return g(a) || (a = T(a)), Me(s, i, a);
+      }
+      t("hasMetadata", st);
+      function nt(s, i, a) {
+        if (!O(i))
+          throw new TypeError();
+        return g(a) || (a = T(a)), ve(s, i, a);
+      }
+      t("hasOwnMetadata", nt);
+      function it(s, i, a) {
+        if (!O(i))
+          throw new TypeError();
+        return g(a) || (a = T(a)), Oe(s, i, a);
+      }
+      t("getMetadata", it);
+      function rt(s, i, a) {
+        if (!O(i))
+          throw new TypeError();
+        return g(a) || (a = T(a)), Pe(s, i, a);
+      }
+      t("getOwnMetadata", rt);
+      function ot(s, i) {
+        if (!O(s))
+          throw new TypeError();
+        return g(i) || (i = T(i)), je(s, i);
+      }
+      t("getMetadataKeys", ot);
+      function at(s, i) {
+        if (!O(s))
+          throw new TypeError();
+        return g(i) || (i = T(i)), Ce(s, i);
+      }
+      t("getOwnMetadataKeys", at);
+      function ct(s, i, a) {
+        if (!O(i))
+          throw new TypeError();
+        if (g(a) || (a = T(a)), !O(i))
+          throw new TypeError();
+        g(a) || (a = T(a));
+        var l = H(
+          i,
+          a,
+          /*Create*/
+          !1
+        );
+        return g(l) ? !1 : l.OrdinaryDeleteMetadata(s, i, a);
+      }
+      t("deleteMetadata", ct);
+      function lt(s, i) {
+        for (var a = s.length - 1; a >= 0; --a) {
+          var l = s[a], v = l(i);
+          if (!g(v) && !A(v)) {
+            if (!ze(v))
+              throw new TypeError();
+            i = v;
+          }
+        }
+        return i;
+      }
+      function ut(s, i, a, l) {
+        for (var v = s.length - 1; v >= 0; --v) {
+          var _ = s[v], P = _(i, a, l);
+          if (!g(P) && !A(P)) {
+            if (!O(P))
+              throw new TypeError();
+            l = P;
+          }
+        }
+        return l;
+      }
+      function Me(s, i, a) {
+        var l = ve(s, i, a);
+        if (l)
+          return !0;
+        var v = ye(i);
+        return A(v) ? !1 : Me(s, v, a);
+      }
+      function ve(s, i, a) {
+        var l = H(
+          i,
+          a,
+          /*Create*/
+          !1
+        );
+        return g(l) ? !1 : Ie(l.OrdinaryHasOwnMetadata(s, i, a));
+      }
+      function Oe(s, i, a) {
+        var l = ve(s, i, a);
+        if (l)
+          return Pe(s, i, a);
+        var v = ye(i);
+        if (!A(v))
+          return Oe(s, v, a);
+      }
+      function Pe(s, i, a) {
+        var l = H(
+          i,
+          a,
+          /*Create*/
+          !1
+        );
+        if (!g(l))
+          return l.OrdinaryGetOwnMetadata(s, i, a);
+      }
+      function _e(s, i, a, l) {
+        var v = H(
+          a,
+          l,
+          /*Create*/
+          !0
+        );
+        v.OrdinaryDefineOwnMetadata(s, i, a, l);
+      }
+      function je(s, i) {
+        var a = Ce(s, i), l = ye(s);
+        if (l === null)
+          return a;
+        var v = je(l, i);
+        if (v.length <= 0)
+          return a;
+        if (a.length <= 0)
+          return v;
+        for (var _ = new de(), P = [], w = 0, u = a; w < u.length; w++) {
+          var h = u[w], d = _.has(h);
+          d || (_.add(h), P.push(h));
+        }
+        for (var f = 0, m = v; f < m.length; f++) {
+          var h = m[f], d = _.has(h);
+          d || (_.add(h), P.push(h));
+        }
+        return P;
+      }
+      function Ce(s, i) {
+        var a = H(
+          s,
+          i,
+          /*create*/
+          !1
+        );
+        return a ? a.OrdinaryOwnMetadataKeys(s, i) : [];
+      }
+      function Ee(s) {
+        if (s === null)
+          return 1;
+        switch (typeof s) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return s === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function g(s) {
+        return s === void 0;
+      }
+      function A(s) {
+        return s === null;
+      }
+      function ht(s) {
+        return typeof s == "symbol";
+      }
+      function O(s) {
+        return typeof s == "object" ? s !== null : typeof s == "function";
+      }
+      function dt(s, i) {
+        switch (Ee(s)) {
+          case 0:
+            return s;
+          case 1:
+            return s;
+          case 2:
+            return s;
+          case 3:
+            return s;
+          case 4:
+            return s;
+          case 5:
+            return s;
+        }
+        var a = "string", l = De(s, p);
+        if (l !== void 0) {
+          var v = l.call(s, a);
+          if (O(v))
+            throw new TypeError();
+          return v;
+        }
+        return ft(s);
+      }
+      function ft(s, i) {
+        var a, l;
+        {
+          var v = s.toString;
+          if (ne(v)) {
+            var l = v.call(s);
+            if (!O(l))
+              return l;
+          }
+          var a = s.valueOf;
+          if (ne(a)) {
+            var l = a.call(s);
+            if (!O(l))
+              return l;
+          }
+        }
+        throw new TypeError();
+      }
+      function Ie(s) {
+        return !!s;
+      }
+      function vt(s) {
+        return "" + s;
+      }
+      function T(s) {
+        var i = dt(s);
+        return ht(i) ? i : vt(i);
+      }
+      function Te(s) {
+        return Array.isArray ? Array.isArray(s) : s instanceof Object ? s instanceof Array : Object.prototype.toString.call(s) === "[object Array]";
+      }
+      function ne(s) {
+        return typeof s == "function";
+      }
+      function ze(s) {
+        return typeof s == "function";
+      }
+      function pt(s) {
+        switch (Ee(s)) {
+          case 3:
+            return !0;
+          case 4:
+            return !0;
+          default:
+            return !1;
+        }
+      }
+      function pe(s, i) {
+        return s === i || s !== s && i !== i;
+      }
+      function De(s, i) {
+        var a = s[i];
+        if (a != null) {
+          if (!ne(a))
+            throw new TypeError();
+          return a;
+        }
+      }
+      function Re(s) {
+        var i = De(s, y);
+        if (!ne(i))
+          throw new TypeError();
+        var a = i.call(s);
+        if (!O(a))
+          throw new TypeError();
+        return a;
+      }
+      function ke(s) {
+        return s.value;
+      }
+      function Be(s) {
+        var i = s.next();
+        return i.done ? !1 : i;
+      }
+      function Ue(s) {
+        var i = s.return;
+        i && i.call(s);
+      }
+      function ye(s) {
+        var i = Object.getPrototypeOf(s);
+        if (typeof s != "function" || s === N || i !== N)
+          return i;
+        var a = s.prototype, l = a && Object.getPrototypeOf(a);
+        if (l == null || l === Object.prototype)
+          return i;
+        var v = l.constructor;
+        return typeof v != "function" || v === s ? i : v;
+      }
+      function yt() {
+        var s;
+        !g($) && typeof n.Reflect < "u" && !($ in n.Reflect) && typeof n.Reflect.defineMetadata == "function" && (s = mt(n.Reflect));
+        var i, a, l, v = new fe(), _ = {
+          registerProvider: P,
+          getProvider: u,
+          setProvider: d
+        };
+        return _;
+        function P(f) {
+          if (!Object.isExtensible(_))
+            throw new Error("Cannot add provider to a frozen registry.");
+          switch (!0) {
+            case s === f:
+              break;
+            case g(i):
+              i = f;
+              break;
+            case i === f:
+              break;
+            case g(a):
+              a = f;
+              break;
+            case a === f:
+              break;
+            default:
+              l === void 0 && (l = new de()), l.add(f);
+              break;
+          }
+        }
+        function w(f, m) {
+          if (!g(i)) {
+            if (i.isProviderFor(f, m))
+              return i;
+            if (!g(a)) {
+              if (a.isProviderFor(f, m))
+                return i;
+              if (!g(l))
+                for (var x = Re(l); ; ) {
+                  var M = Be(x);
+                  if (!M)
+                    return;
+                  var I = ke(M);
+                  if (I.isProviderFor(f, m))
+                    return Ue(x), I;
+                }
+            }
+          }
+          if (!g(s) && s.isProviderFor(f, m))
+            return s;
+        }
+        function u(f, m) {
+          var x = v.get(f), M;
+          return g(x) || (M = x.get(m)), g(M) && (M = w(f, m), g(M) || (g(x) && (x = new Y(), v.set(f, x)), x.set(m, M))), M;
+        }
+        function h(f) {
+          if (g(f))
+            throw new TypeError();
+          return i === f || a === f || !g(l) && l.has(f);
+        }
+        function d(f, m, x) {
+          if (!h(x))
+            throw new Error("Metadata provider not registered.");
+          var M = u(f, m);
+          if (M !== x) {
+            if (!g(M))
+              return !1;
+            var I = v.get(f);
+            g(I) && (I = new Y(), v.set(f, I)), I.set(m, x);
+          }
+          return !0;
+        }
+      }
+      function gt() {
+        var s;
+        return !g($) && O(n.Reflect) && Object.isExtensible(n.Reflect) && (s = n.Reflect[$]), g(s) && (s = yt()), !g($) && O(n.Reflect) && Object.isExtensible(n.Reflect) && Object.defineProperty(n.Reflect, $, {
+          enumerable: !1,
+          configurable: !1,
+          writable: !1,
+          value: s
+        }), s;
+      }
+      function wt(s) {
+        var i = new fe(), a = {
+          isProviderFor: function(h, d) {
+            var f = i.get(h);
+            return g(f) ? !1 : f.has(d);
+          },
+          OrdinaryDefineOwnMetadata: P,
+          OrdinaryHasOwnMetadata: v,
+          OrdinaryGetOwnMetadata: _,
+          OrdinaryOwnMetadataKeys: w,
+          OrdinaryDeleteMetadata: u
+        };
+        return se.registerProvider(a), a;
+        function l(h, d, f) {
+          var m = i.get(h), x = !1;
+          if (g(m)) {
+            if (!f)
+              return;
+            m = new Y(), i.set(h, m), x = !0;
+          }
+          var M = m.get(d);
+          if (g(M)) {
+            if (!f)
+              return;
+            if (M = new Y(), m.set(d, M), !s.setProvider(h, d, a))
+              throw m.delete(d), x && i.delete(h), new Error("Wrong provider for target.");
+          }
+          return M;
+        }
+        function v(h, d, f) {
+          var m = l(
+            d,
+            f,
+            /*Create*/
+            !1
+          );
+          return g(m) ? !1 : Ie(m.has(h));
+        }
+        function _(h, d, f) {
+          var m = l(
+            d,
+            f,
+            /*Create*/
+            !1
+          );
+          if (!g(m))
+            return m.get(h);
+        }
+        function P(h, d, f, m) {
+          var x = l(
+            f,
+            m,
+            /*Create*/
+            !0
+          );
+          x.set(h, d);
+        }
+        function w(h, d) {
+          var f = [], m = l(
+            h,
+            d,
+            /*Create*/
+            !1
+          );
+          if (g(m))
+            return f;
+          for (var x = m.keys(), M = Re(x), I = 0; ; ) {
+            var Ve = Be(M);
+            if (!Ve)
+              return f.length = I, f;
+            var Mt = ke(Ve);
+            try {
+              f[I] = Mt;
+            } catch (Ot) {
+              try {
+                Ue(M);
+              } finally {
+                throw Ot;
+              }
+            }
+            I++;
+          }
+        }
+        function u(h, d, f) {
+          var m = l(
+            d,
+            f,
+            /*Create*/
+            !1
+          );
+          if (g(m) || !m.delete(h))
+            return !1;
+          if (m.size === 0) {
+            var x = i.get(d);
+            g(x) || (x.delete(f), x.size === 0 && i.delete(x));
+          }
+          return !0;
+        }
+      }
+      function mt(s) {
+        var i = s.defineMetadata, a = s.hasOwnMetadata, l = s.getOwnMetadata, v = s.getOwnMetadataKeys, _ = s.deleteMetadata, P = new fe(), w = {
+          isProviderFor: function(u, h) {
+            var d = P.get(u);
+            return !g(d) && d.has(h) ? !0 : v(u, h).length ? (g(d) && (d = new de(), P.set(u, d)), d.add(h), !0) : !1;
+          },
+          OrdinaryDefineOwnMetadata: i,
+          OrdinaryHasOwnMetadata: a,
+          OrdinaryGetOwnMetadata: l,
+          OrdinaryOwnMetadataKeys: v,
+          OrdinaryDeleteMetadata: _
+        };
+        return w;
+      }
+      function H(s, i, a) {
+        var l = se.getProvider(s, i);
+        if (!g(l))
+          return l;
+        if (a) {
+          if (se.setProvider(s, i, Se))
+            return Se;
+          throw new Error("Illegal state.");
+        }
+      }
+      function bt() {
+        var s = {}, i = [], a = (
+          /** @class */
+          (function() {
+            function w(u, h, d) {
+              this._index = 0, this._keys = u, this._values = h, this._selector = d;
+            }
+            return w.prototype["@@iterator"] = function() {
+              return this;
+            }, w.prototype[y] = function() {
+              return this;
+            }, w.prototype.next = function() {
+              var u = this._index;
+              if (u >= 0 && u < this._keys.length) {
+                var h = this._selector(this._keys[u], this._values[u]);
+                return u + 1 >= this._keys.length ? (this._index = -1, this._keys = i, this._values = i) : this._index++, { value: h, done: !1 };
+              }
+              return { value: void 0, done: !0 };
+            }, w.prototype.throw = function(u) {
+              throw this._index >= 0 && (this._index = -1, this._keys = i, this._values = i), u;
+            }, w.prototype.return = function(u) {
+              return this._index >= 0 && (this._index = -1, this._keys = i, this._values = i), { value: u, done: !0 };
+            }, w;
+          })()
+        ), l = (
+          /** @class */
+          (function() {
+            function w() {
+              this._keys = [], this._values = [], this._cacheKey = s, this._cacheIndex = -2;
+            }
+            return Object.defineProperty(w.prototype, "size", {
+              get: function() {
+                return this._keys.length;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), w.prototype.has = function(u) {
+              return this._find(
+                u,
+                /*insert*/
+                !1
+              ) >= 0;
+            }, w.prototype.get = function(u) {
+              var h = this._find(
+                u,
+                /*insert*/
+                !1
+              );
+              return h >= 0 ? this._values[h] : void 0;
+            }, w.prototype.set = function(u, h) {
+              var d = this._find(
+                u,
+                /*insert*/
+                !0
+              );
+              return this._values[d] = h, this;
+            }, w.prototype.delete = function(u) {
+              var h = this._find(
+                u,
+                /*insert*/
+                !1
+              );
+              if (h >= 0) {
+                for (var d = this._keys.length, f = h + 1; f < d; f++)
+                  this._keys[f - 1] = this._keys[f], this._values[f - 1] = this._values[f];
+                return this._keys.length--, this._values.length--, pe(u, this._cacheKey) && (this._cacheKey = s, this._cacheIndex = -2), !0;
+              }
+              return !1;
+            }, w.prototype.clear = function() {
+              this._keys.length = 0, this._values.length = 0, this._cacheKey = s, this._cacheIndex = -2;
+            }, w.prototype.keys = function() {
+              return new a(this._keys, this._values, v);
+            }, w.prototype.values = function() {
+              return new a(this._keys, this._values, _);
+            }, w.prototype.entries = function() {
+              return new a(this._keys, this._values, P);
+            }, w.prototype["@@iterator"] = function() {
+              return this.entries();
+            }, w.prototype[y] = function() {
+              return this.entries();
+            }, w.prototype._find = function(u, h) {
+              if (!pe(this._cacheKey, u)) {
+                this._cacheIndex = -1;
+                for (var d = 0; d < this._keys.length; d++)
+                  if (pe(this._keys[d], u)) {
+                    this._cacheIndex = d;
+                    break;
+                  }
+              }
+              return this._cacheIndex < 0 && h && (this._cacheIndex = this._keys.length, this._keys.push(u), this._values.push(void 0)), this._cacheIndex;
+            }, w;
+          })()
+        );
+        return l;
+        function v(w, u) {
+          return w;
+        }
+        function _(w, u) {
+          return u;
+        }
+        function P(w, u) {
+          return [w, u];
+        }
+      }
+      function xt() {
+        var s = (
+          /** @class */
+          (function() {
+            function i() {
+              this._map = new Y();
+            }
+            return Object.defineProperty(i.prototype, "size", {
+              get: function() {
+                return this._map.size;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), i.prototype.has = function(a) {
+              return this._map.has(a);
+            }, i.prototype.add = function(a) {
+              return this._map.set(a, a), this;
+            }, i.prototype.delete = function(a) {
+              return this._map.delete(a);
+            }, i.prototype.clear = function() {
+              this._map.clear();
+            }, i.prototype.keys = function() {
+              return this._map.keys();
+            }, i.prototype.values = function() {
+              return this._map.keys();
+            }, i.prototype.entries = function() {
+              return this._map.entries();
+            }, i.prototype["@@iterator"] = function() {
+              return this.keys();
+            }, i.prototype[y] = function() {
+              return this.keys();
+            }, i;
+          })()
+        );
+        return s;
+      }
+      function St() {
+        var s = 16, i = R.create(), a = l();
+        return (
+          /** @class */
+          (function() {
+            function u() {
+              this._key = l();
+            }
+            return u.prototype.has = function(h) {
+              var d = v(
+                h,
+                /*create*/
+                !1
+              );
+              return d !== void 0 ? R.has(d, this._key) : !1;
+            }, u.prototype.get = function(h) {
+              var d = v(
+                h,
+                /*create*/
+                !1
+              );
+              return d !== void 0 ? R.get(d, this._key) : void 0;
+            }, u.prototype.set = function(h, d) {
+              var f = v(
+                h,
+                /*create*/
+                !0
+              );
+              return f[this._key] = d, this;
+            }, u.prototype.delete = function(h) {
+              var d = v(
+                h,
+                /*create*/
+                !1
+              );
+              return d !== void 0 ? delete d[this._key] : !1;
+            }, u.prototype.clear = function() {
+              this._key = l();
+            }, u;
+          })()
+        );
+        function l() {
+          var u;
+          do
+            u = "@@WeakMap@@" + w();
+          while (R.has(i, u));
+          return i[u] = !0, u;
+        }
+        function v(u, h) {
+          if (!r.call(u, a)) {
+            if (!h)
+              return;
+            Object.defineProperty(u, a, { value: R.create() });
+          }
+          return u[a];
+        }
+        function _(u, h) {
+          for (var d = 0; d < h; ++d)
+            u[d] = Math.random() * 255 | 0;
+          return u;
+        }
+        function P(u) {
+          if (typeof Uint8Array == "function") {
+            var h = new Uint8Array(u);
+            return typeof crypto < "u" ? crypto.getRandomValues(h) : typeof msCrypto < "u" ? msCrypto.getRandomValues(h) : _(h, u), h;
+          }
+          return _(new Array(u), u);
+        }
+        function w() {
+          var u = P(s);
+          u[6] = u[6] & 79 | 64, u[8] = u[8] & 191 | 128;
+          for (var h = "", d = 0; d < s; ++d) {
+            var f = u[d];
+            (d === 4 || d === 6 || d === 8) && (h += "-"), f < 16 && (h += "0"), h += f.toString(16).toLowerCase();
+          }
+          return h;
+        }
+      }
+      function ge(s) {
+        return s.__ = void 0, delete s.__, s;
+      }
+    });
+  })(o || (o = {})), Ge;
+}
+Lt();
+class qe extends Error {
+  constructor() {
+    super(...arguments), this.name = this.constructor.name;
+  }
+}
+class $t extends qe {
+  constructor(e, t) {
+    super(`"${t}" not found in Mesh "${e}"`);
+  }
+}
+class Ke extends qe {
+  constructor(e) {
+    super(`Invalid binding "${e}". Valid bindings are: string to constructor e.g. ("MyService", MyService) or abstract class to constructor e.g. (MyService, MyServiceImpl) orconstructor to self e.g. (MyService)`);
+  }
+}
+function D(o) {
+  return typeof o == "string" ? o : o.name;
+}
+function At(o) {
+  return typeof o == "function" && o.prototype != null;
+}
+function Gt(o, ...e) {
+  return At(o) ? new o(...e) : o(...e);
+}
+const Je = /* @__PURE__ */ Symbol.for("MESH_REF");
+class ae {
+  constructor(e = "default", t = void 0) {
+    this.name = e, this.parent = t, this.bindings = /* @__PURE__ */ new Map(), this.instances = /* @__PURE__ */ new Map(), this.middlewares = [], this.constant(ae, this), this.injectRef(this);
+  }
+  *[Symbol.iterator]() {
+    yield* this.bindings.entries();
+  }
+  clone() {
+    const e = new ae();
+    return e.parent = this.parent, e.bindings = new Map(this.bindings), e;
+  }
+  connect(e) {
+    const t = this.applyMiddleware(e);
+    return this.injectRef(t), t;
+  }
+  use(e) {
+    return this.middlewares.push(e), this;
+  }
+  service(e, t) {
+    const n = D(e);
+    if (typeof t == "function")
+      return this.bindings.set(n, { type: "service", class: t }), this;
+    if (typeof e == "function")
+      return this.bindings.set(n, { type: "service", class: e }), this;
+    throw new Ke(String(e));
+  }
+  scope(e, t) {
+    const n = D(e);
+    if (typeof t == "function")
+      return this.bindings.set(n, { type: "scope", factory: t }), this;
+    if (typeof e == "function")
+      return this.bindings.set(n, { type: "scope", factory: e }), this;
+    throw new Ke(String(e));
+  }
+  constant(e, t) {
+    const n = D(e);
+    return this.bindings.set(n, { type: "constant", value: t }), this;
+  }
+  alias(e, t) {
+    const n = D(e), r = D(t);
+    return this.bindings.set(n, { type: "alias", key: r }), this;
+  }
+  delete(e) {
+    const t = D(e);
+    return this.bindings.delete(t), this;
+  }
+  resolve(e, t = !0) {
+    const n = this.tryResolve(e, t);
+    if (n === void 0) {
+      const r = D(e);
+      throw new $t(this.name, r);
+    }
+    return n;
+  }
+  tryResolve(e, t = !0) {
+    const n = D(e);
+    let r = this.instances.get(n);
+    if (r)
+      return r;
+    const c = this.bindings.get(n);
+    if (c)
+      return r = this.instantiate(c), r = this.connect(r), this.instances.set(n, r), r;
+    if (t && this.parent)
+      return this.parent.tryResolve(e);
+  }
+  getBinding(e, t = !0) {
+    const n = D(e), r = this.bindings.get(n);
+    if (r)
+      return r;
+    if (t && this.parent)
+      return this.parent.getBinding(e);
+  }
+  *allBindings() {
+    yield* this.bindings.entries(), this.parent && (yield* this.parent.allBindings());
+  }
+  *missingDeps() {
+    for (const e of this.allDeps())
+      this.getBinding(e.key) || (yield e);
+  }
+  *allDeps() {
+    const e = /* @__PURE__ */ new Set();
+    for (const [, t] of this.allBindings())
+      t.type === "service" && (yield* this.traverseClassDeps(t.class, e));
+  }
+  *traverseClassDeps(e, t = /* @__PURE__ */ new Set()) {
+    const n = Kt(e);
+    for (const r of n) {
+      if (t.has(r.key))
+        continue;
+      t.add(r.key), yield r;
+      const c = this.getBinding(r.key);
+      c?.type === "service" && (yield* this.traverseClassDeps(c.class, t));
+    }
+  }
+  instantiate(e) {
+    switch (e.type) {
+      case "alias":
+        return this.resolve(e.key);
+      case "service": {
+        const t = e.class, n = class extends t {
+        };
+        return Object.defineProperty(n, "name", { value: t.name }), this.injectRef(n.prototype), new n();
+      }
+      case "constant":
+        return e.value;
+      case "scope":
+        return (n) => Gt(e.factory, n ?? this);
+    }
+  }
+  applyMiddleware(e) {
+    let t = e;
+    for (const n of this.middlewares)
+      t = n(t);
+    return this.parent && (t = this.parent.applyMiddleware(t)), t;
+  }
+  injectRef(e) {
+    typeof e == "object" && Object.defineProperty(e, Je, {
+      get: () => this,
+      enumerable: !1,
+      configurable: !0
+    });
+  }
+}
+const Ft = [];
+function Kt(o) {
+  const e = [];
+  let t = o;
+  for (; t !== Object.prototype; ) {
+    const n = Ft.filter((r) => r.class === t);
+    e.push(...n), t = Object.getPrototypeOf(t);
+  }
+  return e;
+}
+const Nt = Object.getOwnPropertyNames(Reflect);
+function b(o, e, t = !0) {
+  let n;
+  const r = {};
+  for (const c of Nt)
+    r[c] = function(p, ...y) {
+      let S = n;
+      return S || (S = o[Je].resolve(e)), t && (n = S), Reflect[c](S, ...y);
+    };
+  return new Proxy(o, r);
+}
+class J {
+  constructor() {
+    this.autoCenter = !0, this.allowMultiSelect = !0;
+  }
+  set(e) {
+    Object.assign(this, e);
+  }
+}
+class F {
+  constructor() {
+    this._groups = /* @__PURE__ */ new Map();
+  }
+  on(e, t = /* @__PURE__ */ Symbol()) {
+    let n = this._groups.get(t);
+    return n || (n = /* @__PURE__ */ new Set(), this._groups.set(t, n)), n.add(e), () => this.remove(e, t);
+  }
+  once(e, t = /* @__PURE__ */ Symbol()) {
+    const n = (r) => {
+      e(r), this.remove(n, t);
+    };
+    return this.on(n, t);
+  }
+  remove(e, t) {
+    const n = this._groups.get(t);
+    n && (n.delete(e), n.size === 0 && this._groups.delete(t));
+  }
+  removeAll(e) {
+    this._groups.delete(e);
+  }
+  emit(e) {
+    for (const t of this._groups.values())
+      for (const n of t)
+        n(e);
+  }
+}
+class k {
+  constructor() {
+    this.mounted = new F(), this.unmounted = new F(), this.selectionChanged = new F(), this.dragMove = new F(), this.dragEnd = new F(), this.objectPosUpdated = new F();
+  }
+}
+const we = /* @__PURE__ */ new Map();
+function Yt(o) {
+  return function(t) {
+    return (n, r) => {
+      const c = we.get(o) || [];
+      we.set(o, c), c.push({
+        target: n.constructor,
+        memberName: r,
+        metadata: t
+      });
+    };
+  };
+}
+function Ht(o) {
+  return we.get(o) || [];
+}
+function Xt(o, e, t = !0) {
+  const n = [], r = Ht(o), c = t ? e.allBindings() : e.bindings.entries();
+  for (const [p, y] of c)
+    if (y.type === "service")
+      for (const { target: S, memberName: C, metadata: E } of r)
+        (S === y.class || Object.prototype.isPrototypeOf.call(S, y.class)) && n.push({
+          target: e.resolve(p),
+          memberName: C,
+          metadata: E
+        });
+  return n;
+}
+function Wt(o, e, t = !0, ...n) {
+  return Xt(o, e, t).map((p) => p.target[p.memberName](...n));
+}
+const he = Yt("init");
+async function Ne(o, e = !0) {
+  const t = Wt("init", o, e);
+  await Promise.all(t);
+}
+class ce {
+  constructor() {
+    this.objects = /* @__PURE__ */ new Map();
+  }
+  register(e) {
+    this.objects.set(e.objectId, e);
+  }
+  unregister(e) {
+    this.objects.delete(e);
+  }
+  get(e) {
+    return this.objects.get(e) ?? null;
+  }
+  getAll() {
+    return [...this.objects.values()];
+  }
+}
+class Q {
+  constructor() {
+    this.selectedIds = /* @__PURE__ */ new Set(), this.events = b(this, k);
+  }
+  get size() {
+    return this.selectedIds.size;
+  }
+  getSelectedIds() {
+    return [...this.selectedIds];
+  }
+  getFirst() {
+    return [...this.selectedIds][0] ?? null;
+  }
+  isSelected(e) {
+    return this.selectedIds.has(e);
+  }
+  isSingleSelected(e) {
+    return this.selectedIds.size === 1 && this.selectedIds.has(e);
+  }
+  setSelectedIds(e) {
+    const t = new Set(this.selectedIds);
+    this.selectedIds = new Set(e), this.notifySelectionChanged(t);
+  }
+  selectSingle(e) {
+    if (this.isSingleSelected(e))
+      return;
+    const t = new Set(this.selectedIds);
+    this.selectedIds.clear(), this.selectedIds.add(e), this.notifySelectionChanged(t);
+  }
+  addToSelection(...e) {
+    const t = new Set(this.selectedIds);
+    for (const n of e)
+      this.selectedIds.add(n);
+    this.notifySelectionChanged(t);
+  }
+  removeFromSelection(...e) {
+    const t = new Set(this.selectedIds);
+    for (const n of e)
+      this.selectedIds.delete(n);
+    this.notifySelectionChanged(t);
+  }
+  toggleSelection(e) {
+    if (this.isSelected(e)) {
+      this.removeFromSelection(e);
+      return;
+    }
+    this.addToSelection(e);
+  }
+  deselectAll() {
+    if (this.selectedIds.size === 0)
+      return;
+    const e = new Set(this.selectedIds);
+    this.selectedIds.clear(), this.notifySelectionChanged(e);
+  }
+  notifySelectionChanged(e) {
+    if (e.size === this.selectedIds.size) {
+      let t = !1;
+      for (const n of e)
+        if (!this.selectedIds.has(n)) {
+          t = !0;
+          break;
+        }
+      if (!t)
+        return;
+    }
+    this.events.selectionChanged.emit(this.getSelectedIds());
+  }
+  setSelected(e, t) {
+    if (t) {
+      this.addToSelection(e);
+      return;
+    }
+    this.removeFromSelection(e);
+  }
+}
+class L {
+  constructor() {
+    this.zoom = 1, this.cellSize = 32, this.scrollPos = { x: 0, y: 0 }, this.viewportBox = [{ x: 0, y: 0 }, { x: 0, y: 0 }], this.canvasOrigin = { x: 0, y: 0 }, this.canvasSize = { x: 0, y: 0 };
+  }
+  localToCanvas(e) {
+    return {
+      x: e.x * this.cellSize + this.canvasOrigin.x,
+      y: e.y * this.cellSize + this.canvasOrigin.y
+    };
+  }
+  canvasToLocal(e) {
+    return {
+      x: (e.x - this.canvasOrigin.x) / this.cellSize,
+      y: (e.y - this.canvasOrigin.y) / this.cellSize
+    };
+  }
+  viewportToCanvas(e) {
+    return {
+      x: (e.x + this.scrollPos.x) / this.zoom,
+      y: (e.y + this.scrollPos.y) / this.zoom
+    };
+  }
+  canvasToViewport(e) {
+    return {
+      x: e.x * this.zoom - this.scrollPos.x,
+      y: e.y * this.zoom - this.scrollPos.y
+    };
+  }
+  viewportToLocal(e) {
+    return this.canvasToLocal(this.viewportToCanvas(e));
+  }
+  localToViewport(e) {
+    return this.canvasToViewport(this.localToCanvas(e));
+  }
+  pageToViewport(e) {
+    return {
+      x: e.x - this.viewportBox[0].x,
+      y: e.y - this.viewportBox[0].y
+    };
+  }
+  pageToCanvas(e) {
+    return this.viewportToCanvas(this.pageToViewport(e));
+  }
+  pageToLocal(e) {
+    return this.canvasToLocal(this.pageToCanvas(e));
+  }
+  getViewportCenterInLocal() {
+    const e = Bt(this.viewportBox), t = this.pageToViewport(e);
+    return this.viewportToLocal(t);
+  }
+}
+var Zt = Object.defineProperty, qt = Object.getOwnPropertyDescriptor, Jt = (o, e, t, n) => {
+  for (var r = qt(e, t), c = o.length - 1, p; c >= 0; c--)
+    (p = o[c]) && (r = p(e, t, r) || r);
+  return r && Zt(e, t, r), r;
+};
+class xe {
+  constructor() {
+    this.events = b(this, k), this.selection = b(this, Q), this.objectRegistry = b(this, ce), this.space = b(this, L), this.movingIds = /* @__PURE__ */ new Set(), this.moveOriginPos = null;
+  }
+  init() {
+    this.events.dragMove.on((e) => this.onDragMove(e)), this.events.dragEnd.on(() => this.stopMovingSelection()), this.events.unmounted.on(() => this.stopMovingSelection());
+  }
+  isMoving(e) {
+    return this.movingIds.has(e);
+  }
+  startMovingSelection(e) {
+    this.movingIds = new Set(this.selection.getSelectedIds()), this.moveOriginPos = { x: e.pageX, y: e.pageY };
+    for (const t of this.movingIds)
+      this.objectRegistry.get(t)?.onMoveStart();
+  }
+  onDragMove(e) {
+    if (!this.moveOriginPos)
+      return;
+    const t = this.space.pageToLocal(this.moveOriginPos), n = this.space.pageToLocal({ x: e.pageX, y: e.pageY }), r = We(n, t);
+    for (const c of this.movingIds)
+      this.objectRegistry.get(c)?.onMoveOffset(r);
+  }
+  stopMovingSelection() {
+    for (const e of this.movingIds)
+      this.objectRegistry.get(e)?.onMoveEnd();
+    this.movingIds.clear(), this.moveOriginPos = null;
+  }
+}
+Jt([
+  he()
+], xe.prototype, "init");
+class Qt {
+  constructor(e) {
+    this.config = b(this, J), this.events = b(this, k), this.selection = b(this, Q), this.move = b(this, xe), this.space = b(this, L), this.element = null, this.selectable = !0, this.movable = !0, this.snapToGrid = !0, this.resizable = "none", this.bounds = [{ x: 1, y: 1 }, { x: 10, y: 10 }], this.pos = { x: 0, y: 0 }, this.localPos = { x: 0, y: 0, w: 1, h: 1 }, this.prevLocalPos = { x: 0, y: 0, w: 1, h: 1 }, this.resizingDirection = null, this.resizingBounds = [{ x: 0, y: 0 }, { x: 0, y: 0 }], this.objectId = e;
+  }
+  setElement(e) {
+    this.element = e;
+  }
+  getPos() {
+    return this.pos;
+  }
+  setPos(e) {
+    this.pos = e, !this.isMoving() && !this.isResizing() && this.recalcLocalPos();
+  }
+  getBounds() {
+    return this.bounds;
+  }
+  setBounds(e) {
+    this.bounds = e, !this.isMoving() && !this.isResizing() && this.recalcLocalPos();
+  }
+  isSelectable() {
+    return this.selectable;
+  }
+  setSelectable(e) {
+    this.selectable = e, e || this.selection.removeFromSelection(this.objectId);
+  }
+  isSelected() {
+    return this.selection.isSelected(this.objectId);
+  }
+  setSelected(e) {
+    e && !this.selectable || this.selection.setSelected(this.objectId, e);
+  }
+  isMovable() {
+    return this.movable;
+  }
+  setMovable(e) {
+    this.movable = e;
+  }
+  isSnapToGrid() {
+    return this.snapToGrid;
+  }
+  setSnapToGrid(e) {
+    this.snapToGrid = e;
+  }
+  isResizable() {
+    return this.resizable;
+  }
+  setResizable(e) {
+    this.resizable = e;
+  }
+  /* Render state */
+  getCanvasCoords() {
+    const e = this.space.localToCanvas({ x: this.localPos.x, y: this.localPos.y }), t = this.space.localToCanvas({
+      x: this.localPos.x + this.localPos.w,
+      y: this.localPos.y + this.localPos.h
+    }), n = We(t, e), r = this.pos.w === void 0 ? void 0 : n.x, c = this.pos.h === void 0 ? void 0 : n.y;
+    return {
+      x: e.x,
+      y: e.y,
+      w: r,
+      h: c
+    };
+  }
+  getStyle() {
+    const e = this.getCanvasCoords();
+    return {
+      position: "absolute",
+      left: `${e.x}px`,
+      top: `${e.y}px`,
+      width: e.w === void 0 ? void 0 : `${e.w}px`,
+      height: e.h === void 0 ? void 0 : `${e.h}px`
+    };
+  }
+  isMoving() {
+    return this.move.isMoving(this.objectId);
+  }
+  isResizing() {
+    return this.resizingDirection != null;
+  }
+  commitNewPos(e) {
+    Object.assign(this.pos, e), this.events.objectPosUpdated.emit({
+      objectId: this.objectId,
+      pos: { ...this.pos }
+    });
+  }
+  // Event handlers
+  /**
+   * Click handles selection
+   * Shift/Ctrl/Meta key allows multi-select, if allowed by canvas config
+   */
+  onUiClick(e) {
+    if (!this.selectable)
+      return;
+    const t = e.shiftKey || e.ctrlKey || e.metaKey;
+    if (this.config.allowMultiSelect && t) {
+      this.selection.toggleSelection(this.objectId);
+      return;
+    }
+    this.selection.selectSingle(this.objectId);
+  }
+  /**
+   * Dragging starts moving selected objects, if allowed.
+   * If not selected, single selection is performed first, then dragging starts.
+   */
+  onUiDragStart(e) {
+    this.movable && (this.isSelected() || (e.shiftKey ? this.selection.addToSelection(this.objectId) : this.selection.selectSingle(this.objectId)), !this.isResizing() && !this.isMoving() && this.move.startMovingSelection(e));
+  }
+  /**
+   * Drag move is re-emitted to global canvas events, so that each selected object moves.
+   * CanvasMove will call onMoveOffset on objects that are currently moving.
+   */
+  onUiDragMove(e) {
+    this.events.dragMove.emit(e);
+  }
+  /**
+   * Drag end is re-emitted to global canvas events, so that each selected object stops moving.
+   * CanvasMove will call onMoveEnd on objects that are currently moving.
+   */
+  onUiDragEnd(e) {
+    this.events.dragEnd.emit(e);
+  }
+  /* Moving */
+  /**
+   * Move start is called by CanvasMove when selected objects starts moving.
+   * It saves the previous local position, so that the offset can be calculated.
+   */
+  onMoveStart() {
+    this.prevLocalPos = { ...this.localPos };
+  }
+  /**
+   * Move offset is called by CanvasMove when selected objects moves.
+   * It calculates the new local position based on the previous local position and the offset.
+   */
+  onMoveOffset(e) {
+    this.movable && (this.localPos = {
+      x: this.prevLocalPos.x + e.x,
+      y: this.prevLocalPos.y + e.y,
+      w: this.prevLocalPos.w,
+      h: this.prevLocalPos.h
+    });
+  }
+  /**
+   * Move end is called by CanvasMove when selected objects stops moving.
+   * It commits the new local position to the object.
+   */
+  onMoveEnd() {
+    this.commitNewPos({
+      x: this.maybeRound(this.localPos.x),
+      y: this.maybeRound(this.localPos.y)
+    });
+  }
+  /* Resizing */
+  startResizing(e) {
+    this.resizable === "none" || !this.canResizeInDirection(e) || (this.resizingDirection = e, this.resizingBounds = this.getObjectBounds(), this.selection.selectSingle(this.objectId));
+  }
+  onResizeMove(e) {
+    if (!this.resizingDirection)
+      return;
+    const t = { x: e.pageX, y: e.pageY }, n = this.space.pageToLocal(t), [r, c] = this.getResizingUpdates(this.resizingDirection, n);
+    this.localPos = {
+      x: r.x,
+      y: r.y,
+      w: c.x - r.x,
+      h: c.y - r.y
+    };
+  }
+  onResizeEnd() {
+    this.resizingDirection && (this.commitNewPos({
+      x: this.maybeRound(this.localPos.x),
+      y: this.maybeRound(this.localPos.y),
+      w: z(this.maybeRound(this.localPos.w), this.bounds[0].x, this.bounds[1].x),
+      h: z(this.maybeRound(this.localPos.h), this.bounds[0].y, this.bounds[1].y)
+    }), this.resizingDirection = null);
+  }
+  getResizeDirections() {
+    switch (this.resizable) {
+      case "both":
+        return ["n", "ne", "e", "se", "s", "sw", "w", "nw"];
+      case "horizontal":
+        return ["e", "w"];
+      case "vertical":
+        return ["n", "s"];
+      default:
+        return [];
+    }
+  }
+  getObjectBounds() {
+    const e = { x: this.localPos.x, y: this.localPos.y }, t = {
+      x: this.localPos.x + this.localPos.w,
+      y: this.localPos.y + this.localPos.h
+    };
+    return [e, t];
+  }
+  canResizeInDirection(e) {
+    return this.getResizeDirections().includes(e);
+  }
+  recalcLocalPos() {
+    const e = this.pos.w ?? this.localPos.w, t = this.pos.h ?? this.localPos.h;
+    this.localPos = {
+      x: this.pos.x,
+      y: this.pos.y,
+      w: z(e, this.bounds[0].x, this.bounds[1].x),
+      h: z(t, this.bounds[0].y, this.bounds[1].y)
+    };
+  }
+  maybeRound(e) {
+    return this.snapToGrid ? Math.round(e) : e;
+  }
+  getResizingUpdates(e, t) {
+    const [n, r] = this.resizingBounds, c = z(t.x, r.x - this.bounds[1].x, r.x - this.bounds[0].x), p = z(t.x, n.x + this.bounds[0].x, n.x + this.bounds[1].x), y = z(t.y, r.y - this.bounds[1].y, r.y - this.bounds[0].y), S = z(t.y, n.y + this.bounds[0].y, n.y + this.bounds[1].y);
+    switch (e) {
+      case "n":
+        return [{ x: n.x, y }, { x: r.x, y: r.y }];
+      case "s":
+        return [{ x: n.x, y: n.y }, { x: r.x, y: S }];
+      case "w":
+        return [{ x: c, y: n.y }, { x: r.x, y: r.y }];
+      case "e":
+        return [{ x: n.x, y: n.y }, { x: p, y: r.y }];
+      case "ne":
+        return [{ x: n.x, y }, { x: p, y: r.y }];
+      case "nw":
+        return [{ x: c, y }, { x: r.x, y: r.y }];
+      case "se":
+        return [{ x: n.x, y: n.y }, { x: p, y: S }];
+      case "sw":
+        return [{ x: c, y: n.y }, { x: r.x, y: S }];
+      default:
+        return [{ x: n.x, y: n.y }, { x: r.x, y: r.y }];
+    }
+  }
+}
+const es = {
+  props: {
+    canvasObject: { type: Object, required: !0 },
+    direction: { type: String, required: !0 }
+  }
+};
+function ts(o, e, t, n, r, c) {
+  return V(), q("div", {
+    class: _t(["ResizeHandle", `ResizeHandle-${t.direction}`]),
+    onUidragstart: e[0] || (e[0] = U((p) => t.canvasObject.startResizing(t.direction), ["stop", "prevent"])),
+    onUidragmove: e[1] || (e[1] = U((...p) => t.canvasObject.onResizeMove && t.canvasObject.onResizeMove(...p), ["stop", "prevent"])),
+    onUidragend: e[2] || (e[2] = U((...p) => t.canvasObject.onResizeEnd && t.canvasObject.onResizeEnd(...p), ["stop", "prevent"]))
+  }, null, 34);
+}
+const ss = /* @__PURE__ */ te(es, [["render", ts], ["__scopeId", "data-v-c83350e5"]]), ns = {
+  components: {
+    CanvasObjectResize: ss
+  },
+  props: {
+    canvas: { type: Object, required: !0 },
+    objectId: { type: String, required: !0 },
+    pos: { type: Object, required: !0 },
+    isSelected: { type: Boolean, default: !1 },
+    selectable: { type: Boolean, default: !0 },
+    movable: { type: Boolean, default: !0 },
+    snapToGrid: { type: Boolean, default: !0 },
+    resizable: { type: String, default: "none" },
+    bounds: { type: Array }
+  },
+  emits: [
+    "update:pos",
+    "update:isSelected"
+  ],
+  data() {
+    return {
+      canvasObject: null
+    };
+  },
+  computed: {
+    coords() {
+      return this.canvasObject.getCanvasCoords();
+    },
+    slotProps() {
+      return {
+        canvas: this.canvas,
+        objectId: this.objectId,
+        isSelected: this.canvas.selection.isSelected(this.objectId),
+        coords: this.coords,
+        pos: this.pos
+      };
+    },
+    resizeDirections() {
+      return this.canvasObject.getResizeDirections();
+    }
+  },
+  watch: {
+    pos(o) {
+      this.canvasObject.setPos(o);
+    },
+    isSelected(o) {
+      this.canvasObject.setSelected(o);
+    },
+    selectable(o) {
+      this.canvasObject.setSelectable(o);
+    },
+    movable(o) {
+      this.canvasObject.setMovable(o);
+    },
+    snapToGrid(o) {
+      this.canvasObject.setSnapToGrid(o);
+    },
+    resizable(o) {
+      this.canvasObject.setResizable(o);
+    },
+    bounds(o) {
+      this.canvasObject.setBounds(o);
+    }
+  },
+  created() {
+    this.canvasObject = new Qt(this.objectId), this.canvas.mesh.connect(this.canvasObject), this.canvas.events.objectPosUpdated.on(({ objectId: o, pos: e }) => {
+      o === this.objectId && this.$emit("update:pos", e);
+    }, this), this.canvas.events.selectionChanged.on((o) => {
+      const e = o.includes(this.objectId);
+      this.isSelected !== e && this.$emit("update:isSelected", e);
+    }, this);
+  },
+  mounted() {
+    const o = this.canvasObject;
+    this.canvas.objectRegistry.register(o), o.setElement(this.$refs.rootEl), o.setPos(this.pos), o.setSelectable(this.selectable), o.setMovable(this.movable), o.setSnapToGrid(this.snapToGrid), o.setResizable(this.resizable), o.setBounds(this.bounds), o.setSelected(this.isSelected);
+  },
+  unmounted() {
+    this.canvas.objectRegistry.unregister(this.objectId), this.canvasObject.setElement(null), this.canvas.selection.removeFromSelection(this.objectId), this.canvas.events.objectPosUpdated.removeAll(this), this.canvas.events.selectionChanged.removeAll(this);
+  }
+};
+function is(o, e, t, n, r, c) {
+  const p = oe("CanvasObjectResize");
+  return V(), q("div", {
+    ref: "rootEl",
+    class: "CanvasObject",
+    style: Z(r.canvasObject.getStyle()),
+    onUiclick: e[0] || (e[0] = U((...y) => r.canvasObject.onUiClick && r.canvasObject.onUiClick(...y), ["stop", "prevent"])),
+    onUidragstart: e[1] || (e[1] = U((...y) => r.canvasObject.onUiDragStart && r.canvasObject.onUiDragStart(...y), ["stop", "prevent"])),
+    onUidragmove: e[2] || (e[2] = U((...y) => r.canvasObject.onUiDragMove && r.canvasObject.onUiDragMove(...y), ["stop", "prevent"])),
+    onUidragend: e[3] || (e[3] = U((...y) => r.canvasObject.onUiDragEnd && r.canvasObject.onUiDragEnd(...y), ["stop", "prevent"]))
+  }, [
+    re(o.$slots, "default", jt(Ct(c.slotProps))),
+    (V(!0), q(Et, null, It(c.resizeDirections, (y) => (V(), Xe(p, {
+      key: y,
+      canvasObject: r.canvasObject,
+      direction: y
+    }, null, 8, ["canvasObject", "direction"]))), 128))
+  ], 36);
+}
+const Ms = /* @__PURE__ */ te(ns, [["render", is]]), rs = {
+  components: {
+    CanvasBoxSelect: kt
+  },
+  props: {
+    canvas: { type: Object, required: !0 }
+  },
+  mounted() {
+    this.canvas.mount(this.$refs.viewport);
+  },
+  unmounted() {
+    this.canvas.unmount();
+  },
+  methods: {
+    onCanvasUiClick() {
+      this.canvas.selection.deselectAll();
+    }
+  }
+}, os = { class: "CanvasView" };
+function as(o, e, t, n, r, c) {
+  const p = oe("CanvasBoxSelect");
+  return V(), q("div", os, [
+    j("div", {
+      ref: "viewport",
+      class: "Viewport",
+      onMousedown: e[0] || (e[0] = (...y) => t.canvas.pan.onMouseDown && t.canvas.pan.onMouseDown(...y)),
+      onUidragstart: e[1] || (e[1] = (...y) => t.canvas.boxSelect.onUiDragStart && t.canvas.boxSelect.onUiDragStart(...y)),
+      onUidragmove: e[2] || (e[2] = (...y) => t.canvas.boxSelect.onUiDragMove && t.canvas.boxSelect.onUiDragMove(...y)),
+      onUidragend: e[3] || (e[3] = (...y) => t.canvas.boxSelect.onUiDragEnd && t.canvas.boxSelect.onUiDragEnd(...y)),
+      onUiclick: e[4] || (e[4] = (...y) => c.onCanvasUiClick && c.onCanvasUiClick(...y)),
+      onScroll: e[5] || (e[5] = (...y) => t.canvas.viewport.onScroll && t.canvas.viewport.onScroll(...y)),
+      onWheel: e[6] || (e[6] = (...y) => t.canvas.zoom.onWheel && t.canvas.zoom.onWheel(...y))
+    }, [
+      j("div", {
+        class: "Sizer",
+        style: Z(t.canvas.viewport.getSizerStyle())
+      }, null, 4),
+      j("div", {
+        class: "Canvas",
+        style: Z(t.canvas.viewport.getCanvasStyle())
+      }, [
+        re(o.$slots, "default", {}, void 0, !0),
+        j("div", {
+          class: "Origin",
+          style: Z(t.canvas.viewport.getOriginStyle())
+        }, [
+          re(o.$slots, "origin", {}, void 0, !0)
+        ], 4)
+      ], 4),
+      K(p, { canvas: t.canvas }, null, 8, ["canvas"])
+    ], 544),
+    re(o.$slots, "overlays", {}, void 0, !0)
+  ]);
+}
+const Os = /* @__PURE__ */ te(rs, [["render", as], ["__scopeId", "data-v-52407cb1"]]), cs = {
+  props: {
+    controller: { type: Object, required: !0 }
+  },
+  computed: {
+    page() {
+      return this.controller.inputState.lastMousePos;
+    },
+    viewport() {
+      return this.controller.space.pageToViewport(this.page);
+    },
+    canvas() {
+      return this.controller.space.pageToCanvas(this.page);
+    },
+    local() {
+      return this.controller.space.pageToLocal(this.page);
+    }
+  },
+  methods: {
+    format(o) {
+      return `(${o.x.toFixed(2)}, ${o.y.toFixed(2)})`;
+    }
+  }
+};
+function ls(o, e, t, n, r, c) {
+  const p = oe("HGroup"), y = oe("VGroup");
+  return V(), Xe(y, {
+    class: "DebugCoords",
+    gap: "s"
+  }, {
+    default: G(() => [
+      K(p, { class: "Row" }, {
+        default: G(() => [
+          e[0] || (e[0] = j("strong", null, "page", -1)),
+          j("span", null, X(c.format(c.page)), 1)
+        ]),
+        _: 1
+      }),
+      K(p, { class: "Row" }, {
+        default: G(() => [
+          e[1] || (e[1] = j("strong", null, "viewport", -1)),
+          j("span", null, X(c.format(c.viewport)), 1)
+        ]),
+        _: 1
+      }),
+      K(p, { class: "Row" }, {
+        default: G(() => [
+          e[2] || (e[2] = j("strong", null, "canvas", -1)),
+          j("span", null, X(c.format(c.canvas)), 1)
+        ]),
+        _: 1
+      }),
+      K(p, { class: "Row" }, {
+        default: G(() => [
+          e[3] || (e[3] = j("strong", null, "local", -1)),
+          j("span", null, X(c.format(c.local)), 1)
+        ]),
+        _: 1
+      }),
+      K(p, { class: "Row" }, {
+        default: G(() => [
+          e[4] || (e[4] = j("strong", null, "zoom", -1)),
+          j("span", null, X(t.controller.space.zoom.toFixed(2)), 1)
+        ]),
+        _: 1
+      })
+    ]),
+    _: 1
+  });
+}
+const Ps = /* @__PURE__ */ te(cs, [["render", ls], ["__scopeId", "data-v-54d4bb42"]]);
+var us = Object.defineProperty, hs = Object.getOwnPropertyDescriptor, ds = (o, e, t, n) => {
+  for (var r = hs(e, t), c = o.length - 1, p; c >= 0; c--)
+    (p = o[c]) && (r = p(e, t, r) || r);
+  return r && us(e, t, r), r;
+};
+class ee {
+  constructor() {
+    this.lastMousePos = { x: window.innerWidth * 0.5, y: window.innerHeight * 0.5 }, this.lmbPressed = !1, this.mmbPressed = !1, this.rmbPressed = !1, this.altKey = !1, this.ctrlKey = !1, this.metaKey = !1, this.shiftKey = !1, this.events = b(this, k), this.windowEvents = new ue(window);
+  }
+  init() {
+    this.events.mounted.on(() => {
+      this.windowEvents.add("mousedown", (e) => this.onMouseDown(e)), this.windowEvents.add("mousemove", (e) => this.onMouseMove(e)), this.windowEvents.add("mouseup", (e) => this.onMouseUp(e)), this.windowEvents.add("keydown", (e) => this.onKeyDown(e)), this.windowEvents.add("keyup", (e) => this.onKeyUp(e));
+    }), this.events.unmounted.on(() => {
+      this.windowEvents.removeAll();
+    });
+  }
+  get ctrlOrMetaKey() {
+    return this.ctrlKey || this.metaKey;
+  }
+  onMouseDown(e) {
+    this.lastMousePos = { x: e.pageX, y: e.pageY }, this.lmbPressed = e.button === 0, this.mmbPressed = e.button === 1, this.rmbPressed = e.button === 2;
+  }
+  onMouseMove(e) {
+    this.lastMousePos = { x: e.pageX, y: e.pageY };
+  }
+  onMouseUp(e) {
+    this.lastMousePos = { x: e.pageX, y: e.pageY }, this.lmbPressed = !1, this.mmbPressed = !1, this.rmbPressed = !1;
+  }
+  onKeyDown(e) {
+    this.updateModifiers(e);
+  }
+  onKeyUp(e) {
+    this.updateModifiers(e);
+  }
+  updateModifiers(e) {
+    this.altKey = e.altKey, this.ctrlKey = e.ctrlKey, this.metaKey = e.metaKey, this.shiftKey = e.shiftKey;
+  }
+}
+ds([
+  he()
+], ee.prototype, "init");
+class Ye {
+  constructor() {
+    this.config = b(this, J), this.inputState = b(this, ee), this.objectRegistry = b(this, ce), this.selection = b(this, Q), this.space = b(this, L), this.selectionOriginPos = null, this.initialSelectionIds = /* @__PURE__ */ new Set(), this.objectBoxes = [];
+  }
+  isSelecting() {
+    return this.selectionOriginPos != null;
+  }
+  onUiDragStart(e) {
+    this.config.allowMultiSelect && (this.isSelecting() || (this.selectionOriginPos = { x: e.pageX, y: e.pageY }, e.shiftKey ? this.initialSelectionIds = new Set(this.selection.getSelectedIds()) : (this.initialSelectionIds.clear(), this.selection.deselectAll()), this.captureObjectBoxes()));
+  }
+  onUiDragMove(e) {
+    this.isSelecting() && (e.preventDefault(), this.updateSelection(e));
+  }
+  onUiDragEnd(e) {
+    this.isSelecting() && this.updateSelection(e), this.stopSelecting();
+  }
+  getSelectionBox() {
+    return this.selectionOriginPos ? ie(
+      this.space.pageToLocal(this.selectionOriginPos),
+      this.space.pageToLocal(this.inputState.lastMousePos)
+    ) : null;
+  }
+  getSelectionStyle() {
+    if (!this.selectionOriginPos)
+      return null;
+    const e = ie(this.selectionOriginPos, this.inputState.lastMousePos), t = this.space.pageToCanvas(e[0]), n = this.space.pageToCanvas(e[1]);
+    return {
+      left: `${t.x}px`,
+      top: `${t.y}px`,
+      width: `${n.x - t.x}px`,
+      height: `${n.y - t.y}px`
+    };
+  }
+  stopSelecting() {
+    this.selectionOriginPos = null, this.initialSelectionIds.clear(), this.objectBoxes = [];
+  }
+  captureObjectBoxes() {
+    this.objectBoxes = [];
+    const e = this.space.viewportBox;
+    for (const t of this.objectRegistry.getAll()) {
+      if (!t.isSelectable())
+        continue;
+      const n = t.element;
+      if (!n)
+        continue;
+      const r = n.getBoundingClientRect(), c = ie(
+        { x: r.left, y: r.top },
+        { x: r.right, y: r.bottom }
+      );
+      if (!Le(c, e))
+        continue;
+      const p = ie(
+        this.space.pageToLocal(c[0]),
+        this.space.pageToLocal(c[1])
+      );
+      this.objectBoxes.push([t.objectId, p]);
+    }
+  }
+  updateSelection(e) {
+    const t = this.getSelectionBox();
+    if (!t)
+      return;
+    const n = new Set(this.initialSelectionIds);
+    for (const [r, c] of this.objectBoxes)
+      Le(t, c) && n.add(r);
+    this.selection.setSelectedIds(n);
+  }
+}
+class le {
+  constructor() {
+    this.viewportEl = null, this.windowEvents = new ue(window), this.config = b(this, J), this.space = b(this, L);
+  }
+  mount(e) {
+    this.viewportEl = e, this.recalcCanvasMetrics(), this.updateViewportBox(), this.centerOnOrigin(), this.onScroll(), this.windowEvents.add("resize", () => this.updateViewportBox()), this.windowEvents.add("scroll", () => this.updateViewportBox()), this.config.autoCenter && requestAnimationFrame(() => this.centerOnOrigin());
+  }
+  destroy() {
+    this.windowEvents.removeAll(), this.viewportEl = null, this.space.viewportBox = [{ x: 0, y: 0 }, { x: 0, y: 0 }];
+  }
+  getCanvasStyle() {
+    const e = $e(this.viewportEl, "--canvas-grid-major-color", "#ddd"), t = $e(this.viewportEl, "--canvas-grid-minor-color", "#eee"), n = W(this.viewportEl, "--canvas-grid-subdivisions", 4), r = W(this.viewportEl, "--canvas-grid-major-radius", 2), c = W(this.viewportEl, "--canvas-grid-minor-radius", 1), p = Ut(
+      this.space.cellSize,
+      n,
+      e,
+      r,
+      t,
+      c
+    );
+    return {
+      background: `url(${`data:image/svg+xml;base64,${window.btoa(p)}`}) repeat`,
+      width: `${this.space.canvasSize.x}px`,
+      height: `${this.space.canvasSize.y}px`,
+      transformOrigin: "0 0",
+      transform: `scale(${this.space.zoom})`
+    };
+  }
+  getOriginStyle() {
+    return {
+      left: `${this.space.canvasOrigin.x}px`,
+      top: `${this.space.canvasOrigin.y}px`
+    };
+  }
+  getSizerStyle() {
+    return {
+      width: `${this.space.canvasSize.x * this.space.zoom}px`,
+      height: `${this.space.canvasSize.y * this.space.zoom}px`
+    };
+  }
+  onScroll() {
+    this.viewportEl && (this.space.scrollPos = {
+      x: this.viewportEl.scrollLeft,
+      y: this.viewportEl.scrollTop
+    });
+  }
+  centerOnOrigin() {
+    if (!this.viewportEl)
+      return;
+    const e = this.getViewportSize();
+    this.setViewportScroll({
+      x: this.space.canvasOrigin.x * this.space.zoom - e.x * 0.5,
+      y: this.space.canvasOrigin.y * this.space.zoom - e.y * 0.5
+    });
+  }
+  scrollBy(e, t) {
+    this.viewportEl && this.setViewportScroll({
+      x: this.viewportEl.scrollLeft + e,
+      y: this.viewportEl.scrollTop + t
+    });
+  }
+  scrollToLocalPoint(e) {
+    const t = this.getViewportSize(), n = this.space.localToCanvas(e);
+    this.setViewportScroll({
+      x: n.x * this.space.zoom - t.x * 0.5,
+      y: n.y * this.space.zoom - t.y * 0.5
+    });
+  }
+  setViewportScroll(e) {
+    this.viewportEl && (this.viewportEl.scrollTo({
+      left: Math.max(0, e.x),
+      top: Math.max(0, e.y),
+      behavior: "auto"
+    }), this.onScroll());
+  }
+  updateViewportBox() {
+    if (!this.viewportEl) {
+      this.space.viewportBox = [{ x: 0, y: 0 }, { x: 0, y: 0 }];
+      return;
+    }
+    const e = this.viewportEl.getBoundingClientRect();
+    this.space.viewportBox = [
+      { x: e.left, y: e.top },
+      { x: e.right, y: e.bottom }
+    ];
+  }
+  getViewportSize() {
+    return {
+      x: this.space.viewportBox[1].x - this.space.viewportBox[0].x,
+      y: this.space.viewportBox[1].y - this.space.viewportBox[0].y
+    };
+  }
+  recalcCanvasMetrics() {
+    const e = W(this.viewportEl, "--canvas-margin-cells", 64);
+    this.space.cellSize = W(this.viewportEl, "--canvas-grid-cell-size", 32);
+    const t = e * this.space.cellSize;
+    this.space.canvasSize = { x: t * 2, y: t * 2 }, this.space.canvasOrigin = { x: t, y: t };
+  }
+}
+var fs = Object.defineProperty, vs = Object.getOwnPropertyDescriptor, ps = (o, e, t, n) => {
+  for (var r = vs(e, t), c = o.length - 1, p; c >= 0; c--)
+    (p = o[c]) && (r = p(e, t, r) || r);
+  return r && fs(e, t, r), r;
+};
+class me {
+  constructor() {
+    this.viewport = b(this, le), this.events = b(this, k), this.windowEvents = new ue(window), this.isPanning = !1;
+  }
+  init() {
+    this.events.unmounted.on(() => this.stopPanning());
+  }
+  onMouseDown(e) {
+    e.button === 1 && (e.preventDefault(), this.isPanning = !0, this.windowEvents.add("mousemove", (t) => this.onMouseMove(t)), this.windowEvents.add("mouseup", (t) => this.onMouseUp(t)));
+  }
+  stopPanning() {
+    this.isPanning = !1, this.windowEvents.removeAll();
+  }
+  onMouseMove(e) {
+    this.isPanning && this.viewport.scrollBy(-e.movementX, -e.movementY);
+  }
+  onMouseUp(e) {
+    e.button === 1 && this.stopPanning();
+  }
+}
+ps([
+  he()
+], me.prototype, "init");
+var ys = Object.defineProperty, gs = Object.getOwnPropertyDescriptor, ws = (o, e, t, n) => {
+  for (var r = gs(e, t), c = o.length - 1, p; c >= 0; c--)
+    (p = o[c]) && (r = p(e, t, r) || r);
+  return r && ys(e, t, r), r;
+};
+const ms = [
+  "button",
+  "a",
+  "input",
+  "textarea",
+  "select",
+  '[role="textbox"]',
+  '[role="button"]',
+  "[nodrag]"
+];
+class be {
+  constructor() {
+    this.events = b(this, k), this.inputState = b(this, ee), this.windowEvents = new ue(window), this.lastMouseDownPos = { x: window.innerWidth * 0.5, y: window.innerHeight * 0.5 }, this.lastMouseDownTarget = null, this.dragTarget = null, this.inClickVicinity = !1, this.dragDistance = 4;
+  }
+  init() {
+    this.events.mounted.on(() => {
+      this.windowEvents.add("mousedown", (e) => this.onMouseDown(e)), this.windowEvents.add("mousemove", (e) => this.onMouseMove(e)), this.windowEvents.add("mouseup", (e) => this.onMouseUp(e)), this.windowEvents.add("keydown", (e) => this.onKeyDown(e));
+    }), this.events.unmounted.on(() => {
+      this.windowEvents.removeAll();
+    });
+  }
+  onMouseDown(e) {
+    e.button === 0 && (this.lastMouseDownPos = { x: e.pageX, y: e.pageY }, this.lastMouseDownTarget = e.target, this.inClickVicinity = !0);
+  }
+  onMouseMove(e) {
+    if (!this.inputState.lmbPressed)
+      return;
+    if (this.dragTarget) {
+      this.dragTarget.dispatchEvent(this.cloneMouseEvent("uidragmove", e));
+      return;
+    }
+    if (!this.inClickVicinity || !this.lastMouseDownTarget)
+      return;
+    const t = e.pageX - this.lastMouseDownPos.x, n = e.pageY - this.lastMouseDownPos.y;
+    Math.hypot(t, n) < this.dragDistance || (this.inClickVicinity = !1, this.isDragAllowed(this.lastMouseDownTarget) && (this.dragTarget = this.lastMouseDownTarget, this.dragTarget.dispatchEvent(this.cloneMouseEvent("uidragstart", e))));
+  }
+  onMouseUp(e) {
+    if (e.button !== 0)
+      return;
+    const t = this.dragTarget, n = this.inClickVicinity, r = this.lastMouseDownTarget;
+    this.dragTarget = null, this.inClickVicinity = !1, this.lastMouseDownTarget = null, t && t.dispatchEvent(this.cloneMouseEvent("uidragend", e)), n && r && (r.dispatchEvent(this.cloneMouseEvent("uiclick", e)), this.dispatchActivate(r, e));
+  }
+  onKeyDown(e) {
+    (e.key === "Enter" || e.key === " ") && e.target && (e.target === document.body && e.key === " " && e.preventDefault(), this.dispatchActivate(e.target, e));
+  }
+  dispatchActivate(e, t) {
+    e.closest(":disabled") || e.dispatchEvent(new CustomEvent("uiactivate", { detail: t }));
+  }
+  isDragAllowed(e) {
+    return e instanceof Element ? !e.closest(ms.join(",")) : !1;
+  }
+  cloneMouseEvent(e, t) {
+    return new MouseEvent(e, {
+      bubbles: !0,
+      cancelable: !0,
+      clientX: t.clientX,
+      clientY: t.clientY,
+      screenX: t.screenX,
+      screenY: t.screenY,
+      button: t.button,
+      buttons: t.buttons,
+      ctrlKey: t.ctrlKey,
+      shiftKey: t.shiftKey,
+      altKey: t.altKey,
+      metaKey: t.metaKey
+    });
+  }
+}
+ws([
+  he()
+], be.prototype, "init");
+const B = [0.33, 0.5, 0.6, 0.75, 0.85, 1, 1.15, 1.25, 1.5, 1.75, 2], bs = Math.min(...B), xs = Math.max(...B);
+class He {
+  constructor() {
+    this.viewport = b(this, le), this.space = b(this, L);
+  }
+  onWheel(e) {
+    if (!e.ctrlKey)
+      return;
+    e.preventDefault();
+    const t = z(e.deltaY, -40, 40) / 400, n = Math.exp(-t);
+    this.setZoom(this.space.zoom * n);
+  }
+  setZoom(e) {
+    const t = this.space.getViewportCenterInLocal();
+    this.space.zoom = z(e, bs, xs), this.viewport.scrollToLocalPoint(t);
+  }
+  zoomIn() {
+    const e = this.getClosestZoomStepIndex();
+    e < B.length - 1 && this.setZoom(B[e + 1]);
+  }
+  zoomOut() {
+    const e = this.getClosestZoomStepIndex();
+    e > 0 && this.setZoom(B[e - 1]);
+  }
+  getClosestZoomStepIndex() {
+    let e = 0, t = Number.POSITIVE_INFINITY;
+    for (let n = 0; n < B.length; n++) {
+      const r = Math.abs(B[n] - this.space.zoom);
+      r < t && (t = r, e = n);
+    }
+    return e;
+  }
+}
+class _s {
+  constructor(e = {}) {
+    this.mesh = new ae(), this.boxSelect = b(this, Ye), this.config = b(this, J), this.space = b(this, L), this.viewport = b(this, le), this.pan = b(this, me), this.events = b(this, k), this.inputState = b(this, ee), this.objectRegistry = b(this, ce), this.selection = b(this, Q), this.uiEvents = b(this, be), this.zoom = b(this, He), this.mesh.connect(this), this.mesh.use((t) => Tt(t)), this.mesh.service(Ye), this.mesh.service(le), this.mesh.service(me), this.mesh.service(J), this.mesh.service(L), this.mesh.service(k), this.mesh.service(ee), this.mesh.service(xe), this.mesh.service(ce), this.mesh.service(Q), this.mesh.service(be), this.mesh.service(He), this.config.set(e);
+  }
+  mount(e) {
+    Ne(this.mesh), this.viewport.mount(e), this.events.mounted.emit();
+  }
+  unmount() {
+    Ne(this.mesh), this.viewport.destroy(), this.events.unmounted.emit();
+  }
+}
+export {
+  kt as CanvasBoxSelect,
+  J as CanvasConfig,
+  _s as CanvasController,
+  k as CanvasEvents,
+  ee as CanvasInputState,
+  Ms as CanvasObject,
+  Qt as CanvasObjectController,
+  ce as CanvasObjectRegistry,
+  me as CanvasPan,
+  Q as CanvasSelection,
+  L as CanvasSpace,
+  be as CanvasUiEvents,
+  Os as CanvasView,
+  le as CanvasViewport,
+  He as CanvasZoom,
+  Ps as DebugCoords
+};