@planara/core 1.4.9 → 1.6.0

package/dist/index.es.js

@@ -1,6 +1,824 @@
-import { Program as v, Renderer as p, Transform as g, Camera as f, Geometry as y, Mesh as b, Orbit as c, GridHelper as w, AxesHelper as x, Raycast as I, Vec2 as L, Vec3 as E } from "ogl";
-function M(s) {
-  const e = (
+import { Program as Et, Mesh as Ct, Renderer as St, Transform as xt, Camera as It, Geometry as Lt, Orbit as it, GridHelper as Tt, AxesHelper as At, Raycast as kt, Vec2 as jt, Vec3 as Dt, NormalProgram as Ht, WireMesh as Nt } from "ogl";
+var Ye = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Qe = {};
+/*! *****************************************************************************
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+var Xe;
+function Ft() {
+  if (Xe) return Qe;
+  Xe = 1;
+  var e;
+  return (function(t) {
+    (function(r) {
+      var s = typeof globalThis == "object" ? globalThis : typeof Ye == "object" ? Ye : typeof self == "object" ? self : typeof this == "object" ? this : R(), o = n(t);
+      typeof s.Reflect < "u" && (o = n(s.Reflect, o)), r(o, s), typeof s.Reflect > "u" && (s.Reflect = t);
+      function n(_, S) {
+        return function(j, B) {
+          Object.defineProperty(_, j, { configurable: !0, writable: !0, value: B }), S && S(j, B);
+        };
+      }
+      function l() {
+        try {
+          return Function("return this;")();
+        } catch {
+        }
+      }
+      function w() {
+        try {
+          return (0, eval)("(function() { return this; })()");
+        } catch {
+        }
+      }
+      function R() {
+        return l() || w();
+      }
+    })(function(r, s) {
+      var o = Object.prototype.hasOwnProperty, n = typeof Symbol == "function", l = n && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", w = n && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", R = typeof Object.create == "function", _ = { __proto__: [] } instanceof Array, S = !R && !_, j = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: R ? function() {
+          return me(/* @__PURE__ */ Object.create(null));
+        } : _ ? function() {
+          return me({ __proto__: null });
+        } : function() {
+          return me({});
+        },
+        has: S ? function(i, a) {
+          return o.call(i, a);
+        } : function(i, a) {
+          return a in i;
+        },
+        get: S ? function(i, a) {
+          return o.call(i, a) ? i[a] : void 0;
+        } : function(i, a) {
+          return i[a];
+        }
+      }, B = Object.getPrototypeOf(Function), G = typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : Mt(), Z = typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : bt(), K = typeof WeakMap == "function" ? WeakMap : Ot(), V = n ? Symbol.for("@reflect-metadata:registry") : void 0, J = mt(), re = gt(J);
+      function ne(i, a, u, h) {
+        if (b(u)) {
+          if (!Be(i))
+            throw new TypeError();
+          if (!Ge(a))
+            throw new TypeError();
+          return ie(i, a);
+        } else {
+          if (!Be(i))
+            throw new TypeError();
+          if (!A(a))
+            throw new TypeError();
+          if (!A(h) && !b(h) && !Y(h))
+            throw new TypeError();
+          return Y(h) && (h = void 0), u = $(u), ve(i, a, u, h);
+        }
+      }
+      r("decorate", ne);
+      function c(i, a) {
+        function u(h, M) {
+          if (!A(h))
+            throw new TypeError();
+          if (!b(M) && !yt(M))
+            throw new TypeError();
+          He(i, a, h, M);
+        }
+        return u;
+      }
+      r("metadata", c);
+      function f(i, a, u, h) {
+        if (!A(u))
+          throw new TypeError();
+        return b(h) || (h = $(h)), He(i, a, u, h);
+      }
+      r("defineMetadata", f);
+      function d(i, a, u) {
+        if (!A(a))
+          throw new TypeError();
+        return b(u) || (u = $(u)), ke(i, a, u);
+      }
+      r("hasMetadata", d);
+      function g(i, a, u) {
+        if (!A(a))
+          throw new TypeError();
+        return b(u) || (u = $(u)), pe(i, a, u);
+      }
+      r("hasOwnMetadata", g);
+      function O(i, a, u) {
+        if (!A(a))
+          throw new TypeError();
+        return b(u) || (u = $(u)), je(i, a, u);
+      }
+      r("getMetadata", O);
+      function x(i, a, u) {
+        if (!A(a))
+          throw new TypeError();
+        return b(u) || (u = $(u)), De(i, a, u);
+      }
+      r("getOwnMetadata", x);
+      function P(i, a) {
+        if (!A(i))
+          throw new TypeError();
+        return b(a) || (a = $(a)), Ne(i, a);
+      }
+      r("getMetadataKeys", P);
+      function H(i, a) {
+        if (!A(i))
+          throw new TypeError();
+        return b(a) || (a = $(a)), Fe(i, a);
+      }
+      r("getOwnMetadataKeys", H);
+      function U(i, a, u) {
+        if (!A(a))
+          throw new TypeError();
+        if (b(u) || (u = $(u)), !A(a))
+          throw new TypeError();
+        b(u) || (u = $(u));
+        var h = ee(
+          a,
+          u,
+          /*Create*/
+          !1
+        );
+        return b(h) ? !1 : h.OrdinaryDeleteMetadata(i, a, u);
+      }
+      r("deleteMetadata", U);
+      function ie(i, a) {
+        for (var u = i.length - 1; u >= 0; --u) {
+          var h = i[u], M = h(a);
+          if (!b(M) && !Y(M)) {
+            if (!Ge(M))
+              throw new TypeError();
+            a = M;
+          }
+        }
+        return a;
+      }
+      function ve(i, a, u, h) {
+        for (var M = i.length - 1; M >= 0; --M) {
+          var L = i[M], k = L(a, u, h);
+          if (!b(k) && !Y(k)) {
+            if (!A(k))
+              throw new TypeError();
+            h = k;
+          }
+        }
+        return h;
+      }
+      function ke(i, a, u) {
+        var h = pe(i, a, u);
+        if (h)
+          return !0;
+        var M = _e(a);
+        return Y(M) ? !1 : ke(i, M, u);
+      }
+      function pe(i, a, u) {
+        var h = ee(
+          a,
+          u,
+          /*Create*/
+          !1
+        );
+        return b(h) ? !1 : We(h.OrdinaryHasOwnMetadata(i, a, u));
+      }
+      function je(i, a, u) {
+        var h = pe(i, a, u);
+        if (h)
+          return De(i, a, u);
+        var M = _e(a);
+        if (!Y(M))
+          return je(i, M, u);
+      }
+      function De(i, a, u) {
+        var h = ee(
+          a,
+          u,
+          /*Create*/
+          !1
+        );
+        if (!b(h))
+          return h.OrdinaryGetOwnMetadata(i, a, u);
+      }
+      function He(i, a, u, h) {
+        var M = ee(
+          u,
+          h,
+          /*Create*/
+          !0
+        );
+        M.OrdinaryDefineOwnMetadata(i, a, u, h);
+      }
+      function Ne(i, a) {
+        var u = Fe(i, a), h = _e(i);
+        if (h === null)
+          return u;
+        var M = Ne(h, a);
+        if (M.length <= 0)
+          return u;
+        if (u.length <= 0)
+          return M;
+        for (var L = new Z(), k = [], E = 0, v = u; E < v.length; E++) {
+          var p = v[E], y = L.has(p);
+          y || (L.add(p), k.push(p));
+        }
+        for (var m = 0, C = M; m < C.length; m++) {
+          var p = C[m], y = L.has(p);
+          y || (L.add(p), k.push(p));
+        }
+        return k;
+      }
+      function Fe(i, a) {
+        var u = ee(
+          i,
+          a,
+          /*create*/
+          !1
+        );
+        return u ? u.OrdinaryOwnMetadataKeys(i, a) : [];
+      }
+      function $e(i) {
+        if (i === null)
+          return 1;
+        switch (typeof i) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return i === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function b(i) {
+        return i === void 0;
+      }
+      function Y(i) {
+        return i === null;
+      }
+      function ht(i) {
+        return typeof i == "symbol";
+      }
+      function A(i) {
+        return typeof i == "object" ? i !== null : typeof i == "function";
+      }
+      function dt(i, a) {
+        switch ($e(i)) {
+          case 0:
+            return i;
+          case 1:
+            return i;
+          case 2:
+            return i;
+          case 3:
+            return i;
+          case 4:
+            return i;
+          case 5:
+            return i;
+        }
+        var u = "string", h = Ve(i, l);
+        if (h !== void 0) {
+          var M = h.call(i, u);
+          if (A(M))
+            throw new TypeError();
+          return M;
+        }
+        return vt(i);
+      }
+      function vt(i, a) {
+        var u, h, M;
+        {
+          var L = i.toString;
+          if (se(L)) {
+            var h = L.call(i);
+            if (!A(h))
+              return h;
+          }
+          var u = i.valueOf;
+          if (se(u)) {
+            var h = u.call(i);
+            if (!A(h))
+              return h;
+          }
+        }
+        throw new TypeError();
+      }
+      function We(i) {
+        return !!i;
+      }
+      function pt(i) {
+        return "" + i;
+      }
+      function $(i) {
+        var a = dt(i);
+        return ht(a) ? a : pt(a);
+      }
+      function Be(i) {
+        return Array.isArray ? Array.isArray(i) : i instanceof Object ? i instanceof Array : Object.prototype.toString.call(i) === "[object Array]";
+      }
+      function se(i) {
+        return typeof i == "function";
+      }
+      function Ge(i) {
+        return typeof i == "function";
+      }
+      function yt(i) {
+        switch ($e(i)) {
+          case 3:
+            return !0;
+          case 4:
+            return !0;
+          default:
+            return !1;
+        }
+      }
+      function ye(i, a) {
+        return i === a || i !== i && a !== a;
+      }
+      function Ve(i, a) {
+        var u = i[a];
+        if (u != null) {
+          if (!se(u))
+            throw new TypeError();
+          return u;
+        }
+      }
+      function ze(i) {
+        var a = Ve(i, w);
+        if (!se(a))
+          throw new TypeError();
+        var u = a.call(i);
+        if (!A(u))
+          throw new TypeError();
+        return u;
+      }
+      function Ue(i) {
+        return i.value;
+      }
+      function qe(i) {
+        var a = i.next();
+        return a.done ? !1 : a;
+      }
+      function Ze(i) {
+        var a = i.return;
+        a && a.call(i);
+      }
+      function _e(i) {
+        var a = Object.getPrototypeOf(i);
+        if (typeof i != "function" || i === B || a !== B)
+          return a;
+        var u = i.prototype, h = u && Object.getPrototypeOf(u);
+        if (h == null || h === Object.prototype)
+          return a;
+        var M = h.constructor;
+        return typeof M != "function" || M === i ? a : M;
+      }
+      function _t() {
+        var i;
+        !b(V) && typeof s.Reflect < "u" && !(V in s.Reflect) && typeof s.Reflect.defineMetadata == "function" && (i = wt(s.Reflect));
+        var a, u, h, M = new K(), L = {
+          registerProvider: k,
+          getProvider: v,
+          setProvider: y
+        };
+        return L;
+        function k(m) {
+          if (!Object.isExtensible(L))
+            throw new Error("Cannot add provider to a frozen registry.");
+          switch (!0) {
+            case i === m:
+              break;
+            case b(a):
+              a = m;
+              break;
+            case a === m:
+              break;
+            case b(u):
+              u = m;
+              break;
+            case u === m:
+              break;
+            default:
+              h === void 0 && (h = new Z()), h.add(m);
+              break;
+          }
+        }
+        function E(m, C) {
+          if (!b(a)) {
+            if (a.isProviderFor(m, C))
+              return a;
+            if (!b(u)) {
+              if (u.isProviderFor(m, C))
+                return a;
+              if (!b(h))
+                for (var I = ze(h); ; ) {
+                  var T = qe(I);
+                  if (!T)
+                    return;
+                  var N = Ue(T);
+                  if (N.isProviderFor(m, C))
+                    return Ze(I), N;
+                }
+            }
+          }
+          if (!b(i) && i.isProviderFor(m, C))
+            return i;
+        }
+        function v(m, C) {
+          var I = M.get(m), T;
+          return b(I) || (T = I.get(C)), b(T) && (T = E(m, C), b(T) || (b(I) && (I = new G(), M.set(m, I)), I.set(C, T))), T;
+        }
+        function p(m) {
+          if (b(m))
+            throw new TypeError();
+          return a === m || u === m || !b(h) && h.has(m);
+        }
+        function y(m, C, I) {
+          if (!p(I))
+            throw new Error("Metadata provider not registered.");
+          var T = v(m, C);
+          if (T !== I) {
+            if (!b(T))
+              return !1;
+            var N = M.get(m);
+            b(N) && (N = new G(), M.set(m, N)), N.set(C, I);
+          }
+          return !0;
+        }
+      }
+      function mt() {
+        var i;
+        return !b(V) && A(s.Reflect) && Object.isExtensible(s.Reflect) && (i = s.Reflect[V]), b(i) && (i = _t()), !b(V) && A(s.Reflect) && Object.isExtensible(s.Reflect) && Object.defineProperty(s.Reflect, V, {
+          enumerable: !1,
+          configurable: !1,
+          writable: !1,
+          value: i
+        }), i;
+      }
+      function gt(i) {
+        var a = new K(), u = {
+          isProviderFor: function(p, y) {
+            var m = a.get(p);
+            return b(m) ? !1 : m.has(y);
+          },
+          OrdinaryDefineOwnMetadata: k,
+          OrdinaryHasOwnMetadata: M,
+          OrdinaryGetOwnMetadata: L,
+          OrdinaryOwnMetadataKeys: E,
+          OrdinaryDeleteMetadata: v
+        };
+        return J.registerProvider(u), u;
+        function h(p, y, m) {
+          var C = a.get(p), I = !1;
+          if (b(C)) {
+            if (!m)
+              return;
+            C = new G(), a.set(p, C), I = !0;
+          }
+          var T = C.get(y);
+          if (b(T)) {
+            if (!m)
+              return;
+            if (T = new G(), C.set(y, T), !i.setProvider(p, y, u))
+              throw C.delete(y), I && a.delete(p), new Error("Wrong provider for target.");
+          }
+          return T;
+        }
+        function M(p, y, m) {
+          var C = h(
+            y,
+            m,
+            /*Create*/
+            !1
+          );
+          return b(C) ? !1 : We(C.has(p));
+        }
+        function L(p, y, m) {
+          var C = h(
+            y,
+            m,
+            /*Create*/
+            !1
+          );
+          if (!b(C))
+            return C.get(p);
+        }
+        function k(p, y, m, C) {
+          var I = h(
+            m,
+            C,
+            /*Create*/
+            !0
+          );
+          I.set(p, y);
+        }
+        function E(p, y) {
+          var m = [], C = h(
+            p,
+            y,
+            /*Create*/
+            !1
+          );
+          if (b(C))
+            return m;
+          for (var I = C.keys(), T = ze(I), N = 0; ; ) {
+            var Je = qe(T);
+            if (!Je)
+              return m.length = N, m;
+            var Rt = Ue(Je);
+            try {
+              m[N] = Rt;
+            } catch (Pt) {
+              try {
+                Ze(T);
+              } finally {
+                throw Pt;
+              }
+            }
+            N++;
+          }
+        }
+        function v(p, y, m) {
+          var C = h(
+            y,
+            m,
+            /*Create*/
+            !1
+          );
+          if (b(C) || !C.delete(p))
+            return !1;
+          if (C.size === 0) {
+            var I = a.get(y);
+            b(I) || (I.delete(m), I.size === 0 && a.delete(I));
+          }
+          return !0;
+        }
+      }
+      function wt(i) {
+        var a = i.defineMetadata, u = i.hasOwnMetadata, h = i.getOwnMetadata, M = i.getOwnMetadataKeys, L = i.deleteMetadata, k = new K(), E = {
+          isProviderFor: function(v, p) {
+            var y = k.get(v);
+            return !b(y) && y.has(p) ? !0 : M(v, p).length ? (b(y) && (y = new Z(), k.set(v, y)), y.add(p), !0) : !1;
+          },
+          OrdinaryDefineOwnMetadata: a,
+          OrdinaryHasOwnMetadata: u,
+          OrdinaryGetOwnMetadata: h,
+          OrdinaryOwnMetadataKeys: M,
+          OrdinaryDeleteMetadata: L
+        };
+        return E;
+      }
+      function ee(i, a, u) {
+        var h = J.getProvider(i, a);
+        if (!b(h))
+          return h;
+        if (u) {
+          if (J.setProvider(i, a, re))
+            return re;
+          throw new Error("Illegal state.");
+        }
+      }
+      function Mt() {
+        var i = {}, a = [], u = (
+          /** @class */
+          (function() {
+            function E(v, p, y) {
+              this._index = 0, this._keys = v, this._values = p, this._selector = y;
+            }
+            return E.prototype["@@iterator"] = function() {
+              return this;
+            }, E.prototype[w] = function() {
+              return this;
+            }, E.prototype.next = function() {
+              var v = this._index;
+              if (v >= 0 && v < this._keys.length) {
+                var p = this._selector(this._keys[v], this._values[v]);
+                return v + 1 >= this._keys.length ? (this._index = -1, this._keys = a, this._values = a) : this._index++, { value: p, done: !1 };
+              }
+              return { value: void 0, done: !0 };
+            }, E.prototype.throw = function(v) {
+              throw this._index >= 0 && (this._index = -1, this._keys = a, this._values = a), v;
+            }, E.prototype.return = function(v) {
+              return this._index >= 0 && (this._index = -1, this._keys = a, this._values = a), { value: v, done: !0 };
+            }, E;
+          })()
+        ), h = (
+          /** @class */
+          (function() {
+            function E() {
+              this._keys = [], this._values = [], this._cacheKey = i, this._cacheIndex = -2;
+            }
+            return Object.defineProperty(E.prototype, "size", {
+              get: function() {
+                return this._keys.length;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), E.prototype.has = function(v) {
+              return this._find(
+                v,
+                /*insert*/
+                !1
+              ) >= 0;
+            }, E.prototype.get = function(v) {
+              var p = this._find(
+                v,
+                /*insert*/
+                !1
+              );
+              return p >= 0 ? this._values[p] : void 0;
+            }, E.prototype.set = function(v, p) {
+              var y = this._find(
+                v,
+                /*insert*/
+                !0
+              );
+              return this._values[y] = p, this;
+            }, E.prototype.delete = function(v) {
+              var p = this._find(
+                v,
+                /*insert*/
+                !1
+              );
+              if (p >= 0) {
+                for (var y = this._keys.length, m = p + 1; m < y; m++)
+                  this._keys[m - 1] = this._keys[m], this._values[m - 1] = this._values[m];
+                return this._keys.length--, this._values.length--, ye(v, this._cacheKey) && (this._cacheKey = i, this._cacheIndex = -2), !0;
+              }
+              return !1;
+            }, E.prototype.clear = function() {
+              this._keys.length = 0, this._values.length = 0, this._cacheKey = i, this._cacheIndex = -2;
+            }, E.prototype.keys = function() {
+              return new u(this._keys, this._values, M);
+            }, E.prototype.values = function() {
+              return new u(this._keys, this._values, L);
+            }, E.prototype.entries = function() {
+              return new u(this._keys, this._values, k);
+            }, E.prototype["@@iterator"] = function() {
+              return this.entries();
+            }, E.prototype[w] = function() {
+              return this.entries();
+            }, E.prototype._find = function(v, p) {
+              if (!ye(this._cacheKey, v)) {
+                this._cacheIndex = -1;
+                for (var y = 0; y < this._keys.length; y++)
+                  if (ye(this._keys[y], v)) {
+                    this._cacheIndex = y;
+                    break;
+                  }
+              }
+              return this._cacheIndex < 0 && p && (this._cacheIndex = this._keys.length, this._keys.push(v), this._values.push(void 0)), this._cacheIndex;
+            }, E;
+          })()
+        );
+        return h;
+        function M(E, v) {
+          return E;
+        }
+        function L(E, v) {
+          return v;
+        }
+        function k(E, v) {
+          return [E, v];
+        }
+      }
+      function bt() {
+        var i = (
+          /** @class */
+          (function() {
+            function a() {
+              this._map = new G();
+            }
+            return Object.defineProperty(a.prototype, "size", {
+              get: function() {
+                return this._map.size;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), a.prototype.has = function(u) {
+              return this._map.has(u);
+            }, a.prototype.add = function(u) {
+              return this._map.set(u, u), this;
+            }, a.prototype.delete = function(u) {
+              return this._map.delete(u);
+            }, a.prototype.clear = function() {
+              this._map.clear();
+            }, a.prototype.keys = function() {
+              return this._map.keys();
+            }, a.prototype.values = function() {
+              return this._map.keys();
+            }, a.prototype.entries = function() {
+              return this._map.entries();
+            }, a.prototype["@@iterator"] = function() {
+              return this.keys();
+            }, a.prototype[w] = function() {
+              return this.keys();
+            }, a;
+          })()
+        );
+        return i;
+      }
+      function Ot() {
+        var i = 16, a = j.create(), u = h();
+        return (
+          /** @class */
+          (function() {
+            function v() {
+              this._key = h();
+            }
+            return v.prototype.has = function(p) {
+              var y = M(
+                p,
+                /*create*/
+                !1
+              );
+              return y !== void 0 ? j.has(y, this._key) : !1;
+            }, v.prototype.get = function(p) {
+              var y = M(
+                p,
+                /*create*/
+                !1
+              );
+              return y !== void 0 ? j.get(y, this._key) : void 0;
+            }, v.prototype.set = function(p, y) {
+              var m = M(
+                p,
+                /*create*/
+                !0
+              );
+              return m[this._key] = y, this;
+            }, v.prototype.delete = function(p) {
+              var y = M(
+                p,
+                /*create*/
+                !1
+              );
+              return y !== void 0 ? delete y[this._key] : !1;
+            }, v.prototype.clear = function() {
+              this._key = h();
+            }, v;
+          })()
+        );
+        function h() {
+          var v;
+          do
+            v = "@@WeakMap@@" + E();
+          while (j.has(a, v));
+          return a[v] = !0, v;
+        }
+        function M(v, p) {
+          if (!o.call(v, u)) {
+            if (!p)
+              return;
+            Object.defineProperty(v, u, { value: j.create() });
+          }
+          return v[u];
+        }
+        function L(v, p) {
+          for (var y = 0; y < p; ++y)
+            v[y] = Math.random() * 255 | 0;
+          return v;
+        }
+        function k(v) {
+          if (typeof Uint8Array == "function") {
+            var p = new Uint8Array(v);
+            return typeof crypto < "u" ? crypto.getRandomValues(p) : typeof msCrypto < "u" ? msCrypto.getRandomValues(p) : L(p, v), p;
+          }
+          return L(new Array(v), v);
+        }
+        function E() {
+          var v = k(i);
+          v[6] = v[6] & 79 | 64, v[8] = v[8] & 191 | 128;
+          for (var p = "", y = 0; y < i; ++y) {
+            var m = v[y];
+            (y === 4 || y === 6 || y === 8) && (p += "-"), m < 16 && (p += "0"), p += m.toString(16).toLowerCase();
+          }
+          return p;
+        }
+      }
+      function me(i) {
+        return i.__ = void 0, delete i.__, i;
+      }
+    });
+  })(e || (e = {})), Qe;
+}
+Ft();
+function $t(e) {
+  const t = (
     /* glsl */
     `
     attribute vec3 position;
@@ -17,34 +835,58 @@ function M(s) {
       gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
     }
   `
-  ), t = (
+  ), r = (
     /* glsl */
     `
     precision highp float;
 
     uniform float uHit;
+    uniform float uSelected;
 
     varying vec3 vNormal;
 
     void main() {
       vec3 normal = normalize(vNormal);
       float lighting = dot(normal, normalize(vec3(-0.3, 0.8, 0.6)));
-      vec3 color = mix(vec3(0.2, 0.8, 1.0), vec3(1.0, 0.2, 0.8), uHit);
-      gl_FragColor.rgb = color + lighting * 0.1;
-      gl_FragColor.a = 1.0;
+
+      // Базовый цвет меша
+      vec3 baseColor = vec3(0.2, 0.8, 1.0);
+
+      // Цвет при наведении (hover)
+      vec3 hoverColor = vec3(1.0, 1.0, 0.1);
+
+      // Цвет при клике (selected)
+      vec3 selectedColor = vec3(1.0, 0.3, 0.3);
+
+      // Применяем логику подсветки:
+      // приоритет: выделение > hover > обычный цвет
+      vec3 color = mix(baseColor, hoverColor, uHit);
+      color = mix(color, selectedColor, uSelected);
+
+      // Немного света для объема
+      color += lighting * 0.1;
+
+      gl_FragColor = vec4(color, 1.0);
     }
   `
   );
-  return new v(s, {
-    vertex: e,
-    fragment: t,
+  return new Et(e, {
+    vertex: t,
+    fragment: r,
     cullFace: !1,
     uniforms: {
-      uHit: { value: 0 }
+      uHit: { value: 0 },
+      uSelected: { value: 0 }
     }
   });
 }
-class u {
+class Wt extends Ct {
+  isHit;
+  constructor(t, r) {
+    super(t, r), this.isHit = !1;
+  }
+}
+class st {
   /** Экземпляр рендерера OGL */
   gl;
   /** Корневой объект сцены */
@@ -61,8 +903,8 @@ class u {
    * Конструктор рендерера
    * @param canvas - HTMLCanvasElement для рендеринга
    */
-  constructor(e) {
-    this.canvas = e, this.gl = new p({ canvas: e, dpr: 2 }), this.gl.setSize(e.clientWidth, e.clientHeight), this.gl.gl.clearColor(0.1, 0.1, 0.1, 1), this.scene = new g(), this.camera = new f(this.gl.gl, { fov: 45 }), this.camera.position.set(1, 1, 7), this.camera.lookAt([0, 0, 0]), this.program = M(this.gl.gl), this.meshes = [];
+  constructor(t) {
+    this.canvas = t, this.gl = new St({ canvas: t, dpr: 2 }), this.gl.setSize(t.clientWidth, t.clientHeight), this.gl.gl.clearColor(0.1, 0.1, 0.1, 1), this.scene = new xt(), this.camera = new It(this.gl.gl, { fov: 45 }), this.camera.position.set(1, 1, 7), this.camera.lookAt([0, 0, 0]), this.program = $t(this.gl.gl), this.meshes = [];
   }
   /**
    * Обновляет размер рендерера и камеры при изменении размеров canvas.
@@ -89,111 +931,980 @@ class u {
   }
   /**
    * Публичный метод для добавления фигуры.
-   * @param figure Данные фигуры: position, normal, uv
+   * @param figure - Данные фигуры: position, normal, uv
    */
-  addFigure(e) {
-    const t = new y(this.gl.gl, {
-      position: { size: 3, data: new Float32Array(e.position) },
-      normal: { size: 3, data: new Float32Array(e.normal ?? []) },
-      uv: { size: 2, data: new Float32Array(e.uv ?? []) }
-    }), i = new b(this.gl.gl, {
-      geometry: t,
+  addFigure(t) {
+    const r = new Lt(this.gl.gl, {
+      position: { size: 3, data: new Float32Array(t.position) },
+      normal: { size: 3, data: new Float32Array(t.normal ?? []) },
+      uv: { size: 2, data: new Float32Array(t.uv ?? []) }
+    }), s = new Wt(this.gl.gl, {
+      geometry: r,
       program: this.program
     });
-    return i.setParent(this.scene), this.meshes.push(i), i;
+    return s.setParent(this.scene), this.meshes.push(s), s;
+  }
+  /**
+   * Добавляет фигуру в сцену и сохраняет его во внутреннем массиве.
+   *
+   * @param mesh - Фигура для добавления в сцену.
+   * @internal
+   */
+  addMesh(t) {
+    this.scene.addChild(t);
+  }
+  /**
+   * Возвращает WebGL контекст рендерера.
+   *
+   * @returns Контекст WebGL (OGLRenderingContext) текущей сцены.
+   * @internal
+   */
+  getContext() {
+    return this.gl.gl;
+  }
+  /**
+   * Убирает фигуру со сцены
+   *
+   * @param mesh - Фигура для удаления со сцены.
+   * @internal
+   */
+  removeMesh(t) {
+    this.scene.removeChild(t);
+  }
+  /**
+   * Возвращает список всех фигур, находящихся в сцене.
+   *
+   * @returns Массив текущих фигур.
+   * @internal
+   */
+  getMeshes() {
+    return this.meshes;
+  }
+  /**
+   * Возвращает настройку для рендеринга.
+   *
+   * @returns Program для настройки рендеринга моделей.
+   * @internal
+   */
+  getProgram() {
+    return this.program;
   }
   /** Деструктор */
   destroy() {
     this.meshes && (this.meshes.length = 0, this.meshes = []), this.scene = null, this.camera = null, this.program = null, this.gl = null, this.canvas = null;
   }
 }
-class P extends c {
+class Bt extends it {
   /** Используется ли Orbit-controls */
   isInteracting = !1;
-  element;
-  constructor(e, t = {}) {
-    super(e, t), this.element = t.element || document, this.element.addEventListener("mousedown", () => this.isInteracting = !0), this.element.addEventListener("mouseup", () => this.isInteracting = !1), this.element.addEventListener("touchstart", () => this.isInteracting = !0), this.element.addEventListener("touchend", () => this.isInteracting = !1);
+  _element;
+  constructor(t, r = {}) {
+    super(t, r), this._element = r.element || document, this._element.addEventListener("mousedown", () => this.isInteracting = !0), this._element.addEventListener("mouseup", () => this.isInteracting = !1), this._element.addEventListener("touchstart", () => this.isInteracting = !0), this._element.addEventListener("touchend", () => this.isInteracting = !1);
   }
   /** Очистка новых обработчиков событий */
   destroy() {
-    this.element.removeEventListener("mousedown", () => this.isInteracting = !0), this.element.removeEventListener("mouseup", () => this.isInteracting = !1), this.element.removeEventListener("touchstart", () => this.isInteracting = !0), this.element.removeEventListener("touchend", () => this.isInteracting = !1);
+    this._element.removeEventListener("mousedown", () => this.isInteracting = !0), this._element.removeEventListener("mouseup", () => this.isInteracting = !1), this._element.removeEventListener("touchstart", () => this.isInteracting = !0), this._element.removeEventListener("touchend", () => this.isInteracting = !1);
   }
 }
-class F extends u {
-  /** Orbit-контроллер для управления камерой */
-  orbit;
-  /** Raycast для подсветки моделей при наведении */
-  raycast;
-  /** Курсор мыши для остлеживания наведения на 3D-модель */
-  mouse;
-  /** Были ли зарегистрированы обработчики событий для мыши */
-  isEventListenersAdded;
+var we;
+(function(e) {
+  e[e.Transient = 0] = "Transient", e[e.Singleton = 1] = "Singleton", e[e.ResolutionScoped = 2] = "ResolutionScoped", e[e.ContainerScoped = 3] = "ContainerScoped";
+})(we || (we = {}));
+const D = we;
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var Me = function(e, t) {
+  return Me = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, s) {
+    r.__proto__ = s;
+  } || function(r, s) {
+    for (var o in s) s.hasOwnProperty(o) && (r[o] = s[o]);
+  }, Me(e, t);
+};
+function Te(e, t) {
+  Me(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+function Gt(e, t, r, s) {
+  function o(n) {
+    return n instanceof r ? n : new r(function(l) {
+      l(n);
+    });
+  }
+  return new (r || (r = Promise))(function(n, l) {
+    function w(S) {
+      try {
+        _(s.next(S));
+      } catch (j) {
+        l(j);
+      }
+    }
+    function R(S) {
+      try {
+        _(s.throw(S));
+      } catch (j) {
+        l(j);
+      }
+    }
+    function _(S) {
+      S.done ? n(S.value) : o(S.value).then(w, R);
+    }
+    _((s = s.apply(e, [])).next());
+  });
+}
+function Vt(e, t) {
+  var r = { label: 0, sent: function() {
+    if (n[0] & 1) throw n[1];
+    return n[1];
+  }, trys: [], ops: [] }, s, o, n, l;
+  return l = { next: w(0), throw: w(1), return: w(2) }, typeof Symbol == "function" && (l[Symbol.iterator] = function() {
+    return this;
+  }), l;
+  function w(_) {
+    return function(S) {
+      return R([_, S]);
+    };
+  }
+  function R(_) {
+    if (s) throw new TypeError("Generator is already executing.");
+    for (; r; ) try {
+      if (s = 1, o && (n = _[0] & 2 ? o.return : _[0] ? o.throw || ((n = o.return) && n.call(o), 0) : o.next) && !(n = n.call(o, _[1])).done) return n;
+      switch (o = 0, n && (_ = [_[0] & 2, n.value]), _[0]) {
+        case 0:
+        case 1:
+          n = _;
+          break;
+        case 4:
+          return r.label++, { value: _[1], done: !1 };
+        case 5:
+          r.label++, o = _[1], _ = [0];
+          continue;
+        case 7:
+          _ = r.ops.pop(), r.trys.pop();
+          continue;
+        default:
+          if (n = r.trys, !(n = n.length > 0 && n[n.length - 1]) && (_[0] === 6 || _[0] === 2)) {
+            r = 0;
+            continue;
+          }
+          if (_[0] === 3 && (!n || _[1] > n[0] && _[1] < n[3])) {
+            r.label = _[1];
+            break;
+          }
+          if (_[0] === 6 && r.label < n[1]) {
+            r.label = n[1], n = _;
+            break;
+          }
+          if (n && r.label < n[2]) {
+            r.label = n[2], r.ops.push(_);
+            break;
+          }
+          n[2] && r.ops.pop(), r.trys.pop();
+          continue;
+      }
+      _ = t.call(e, r);
+    } catch (S) {
+      _ = [6, S], o = 0;
+    } finally {
+      s = n = 0;
+    }
+    if (_[0] & 5) throw _[1];
+    return { value: _[0] ? _[1] : void 0, done: !0 };
+  }
+}
+function oe(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, r = t && e[t], s = 0;
+  if (r) return r.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && s >= e.length && (e = void 0), { value: e && e[s++], done: !e };
+    }
+  };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function ce(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r) return e;
+  var s = r.call(e), o, n = [], l;
+  try {
+    for (; (t === void 0 || t-- > 0) && !(o = s.next()).done; ) n.push(o.value);
+  } catch (w) {
+    l = { error: w };
+  } finally {
+    try {
+      o && !o.done && (r = s.return) && r.call(s);
+    } finally {
+      if (l) throw l.error;
+    }
+  }
+  return n;
+}
+function q() {
+  for (var e = [], t = 0; t < arguments.length; t++)
+    e = e.concat(ce(arguments[t]));
+  return e;
+}
+var be = "injectionTokens";
+function zt(e) {
+  var t = Reflect.getMetadata("design:paramtypes", e) || [], r = Reflect.getOwnMetadata(be, e) || {};
+  return Object.keys(r).forEach(function(s) {
+    t[+s] = r[s];
+  }), t;
+}
+function ot(e, t) {
+  return function(r, s, o) {
+    var n = Reflect.getOwnMetadata(be, r) || {};
+    n[o] = e, Reflect.defineMetadata(be, n, r);
+  };
+}
+function at(e) {
+  return !!e.useClass;
+}
+function Oe(e) {
+  return !!e.useFactory;
+}
+var ut = (function() {
+  function e(t) {
+    this.wrap = t, this.reflectMethods = [
+      "get",
+      "getPrototypeOf",
+      "setPrototypeOf",
+      "getOwnPropertyDescriptor",
+      "defineProperty",
+      "has",
+      "set",
+      "deleteProperty",
+      "apply",
+      "construct",
+      "ownKeys"
+    ];
+  }
+  return e.prototype.createProxy = function(t) {
+    var r = this, s = {}, o = !1, n, l = function() {
+      return o || (n = t(r.wrap()), o = !0), n;
+    };
+    return new Proxy(s, this.createHandler(l));
+  }, e.prototype.createHandler = function(t) {
+    var r = {}, s = function(o) {
+      r[o] = function() {
+        for (var n = [], l = 0; l < arguments.length; l++)
+          n[l] = arguments[l];
+        n[0] = t();
+        var w = Reflect[o];
+        return w.apply(void 0, q(n));
+      };
+    };
+    return this.reflectMethods.forEach(s), r;
+  }, e;
+})();
+function Q(e) {
+  return typeof e == "string" || typeof e == "symbol";
+}
+function Ut(e) {
+  return typeof e == "object" && "token" in e && "multiple" in e;
+}
+function Ke(e) {
+  return typeof e == "object" && "token" in e && "transform" in e;
+}
+function qt(e) {
+  return typeof e == "function" || e instanceof ut;
+}
+function le(e) {
+  return !!e.useToken;
+}
+function fe(e) {
+  return e.useValue != null;
+}
+function Zt(e) {
+  return at(e) || fe(e) || le(e) || Oe(e);
+}
+var Ae = (function() {
+  function e() {
+    this._registryMap = /* @__PURE__ */ new Map();
+  }
+  return e.prototype.entries = function() {
+    return this._registryMap.entries();
+  }, e.prototype.getAll = function(t) {
+    return this.ensure(t), this._registryMap.get(t);
+  }, e.prototype.get = function(t) {
+    this.ensure(t);
+    var r = this._registryMap.get(t);
+    return r[r.length - 1] || null;
+  }, e.prototype.set = function(t, r) {
+    this.ensure(t), this._registryMap.get(t).push(r);
+  }, e.prototype.setAll = function(t, r) {
+    this._registryMap.set(t, r);
+  }, e.prototype.has = function(t) {
+    return this.ensure(t), this._registryMap.get(t).length > 0;
+  }, e.prototype.clear = function() {
+    this._registryMap.clear();
+  }, e.prototype.ensure = function(t) {
+    this._registryMap.has(t) || this._registryMap.set(t, []);
+  }, e;
+})(), Jt = (function(e) {
+  Te(t, e);
+  function t() {
+    return e !== null && e.apply(this, arguments) || this;
+  }
+  return t;
+})(Ae), ae = /* @__PURE__ */ (function() {
+  function e() {
+    this.scopedResolutions = /* @__PURE__ */ new Map();
+  }
+  return e;
+})();
+function Yt(e, t) {
+  if (e === null)
+    return "at position #" + t;
+  var r = e.split(",")[t].trim();
+  return '"' + r + '" at position #' + t;
+}
+function Qt(e, t, r) {
+  return r === void 0 && (r = "    "), q([e], t.message.split(`
+`).map(function(s) {
+    return r + s;
+  })).join(`
+`);
+}
+function Xt(e, t, r) {
+  var s = ce(e.toString().match(/constructor\(([\w, ]+)\)/) || [], 2), o = s[1], n = o === void 0 ? null : o, l = Yt(n, t);
+  return Qt("Cannot inject the dependency " + l + ' of "' + e.name + '" constructor. Reason:', r);
+}
+function Kt(e) {
+  if (typeof e.dispose != "function")
+    return !1;
+  var t = e.dispose;
+  return !(t.length > 0);
+}
+var er = (function(e) {
+  Te(t, e);
+  function t() {
+    return e !== null && e.apply(this, arguments) || this;
+  }
+  return t;
+})(Ae), tr = (function(e) {
+  Te(t, e);
+  function t() {
+    return e !== null && e.apply(this, arguments) || this;
+  }
+  return t;
+})(Ae), rr = /* @__PURE__ */ (function() {
+  function e() {
+    this.preResolution = new er(), this.postResolution = new tr();
+  }
+  return e;
+})(), lt = /* @__PURE__ */ new Map(), nr = (function() {
+  function e(t) {
+    this.parent = t, this._registry = new Jt(), this.interceptors = new rr(), this.disposed = !1, this.disposables = /* @__PURE__ */ new Set();
+  }
+  return e.prototype.register = function(t, r, s) {
+    s === void 0 && (s = { lifecycle: D.Transient }), this.ensureNotDisposed();
+    var o;
+    if (Zt(r) ? o = r : o = { useClass: r }, le(o))
+      for (var n = [t], l = o; l != null; ) {
+        var w = l.useToken;
+        if (n.includes(w))
+          throw new Error("Token registration cycle detected! " + q(n, [w]).join(" -> "));
+        n.push(w);
+        var R = this._registry.get(w);
+        R && le(R.provider) ? l = R.provider : l = null;
+      }
+    if ((s.lifecycle === D.Singleton || s.lifecycle == D.ContainerScoped || s.lifecycle == D.ResolutionScoped) && (fe(o) || Oe(o)))
+      throw new Error('Cannot use lifecycle "' + D[s.lifecycle] + '" with ValueProviders or FactoryProviders');
+    return this._registry.set(t, { provider: o, options: s }), this;
+  }, e.prototype.registerType = function(t, r) {
+    return this.ensureNotDisposed(), Q(r) ? this.register(t, {
+      useToken: r
+    }) : this.register(t, {
+      useClass: r
+    });
+  }, e.prototype.registerInstance = function(t, r) {
+    return this.ensureNotDisposed(), this.register(t, {
+      useValue: r
+    });
+  }, e.prototype.registerSingleton = function(t, r) {
+    if (this.ensureNotDisposed(), Q(t)) {
+      if (Q(r))
+        return this.register(t, {
+          useToken: r
+        }, { lifecycle: D.Singleton });
+      if (r)
+        return this.register(t, {
+          useClass: r
+        }, { lifecycle: D.Singleton });
+      throw new Error('Cannot register a type name as a singleton without a "to" token');
+    }
+    var s = t;
+    return r && !Q(r) && (s = r), this.register(t, {
+      useClass: s
+    }, { lifecycle: D.Singleton });
+  }, e.prototype.resolve = function(t, r, s) {
+    r === void 0 && (r = new ae()), s === void 0 && (s = !1), this.ensureNotDisposed();
+    var o = this.getRegistration(t);
+    if (!o && Q(t)) {
+      if (s)
+        return;
+      throw new Error('Attempted to resolve unregistered dependency token: "' + t.toString() + '"');
+    }
+    if (this.executePreResolutionInterceptor(t, "Single"), o) {
+      var n = this.resolveRegistration(o, r);
+      return this.executePostResolutionInterceptor(t, n, "Single"), n;
+    }
+    if (qt(t)) {
+      var n = this.construct(t, r);
+      return this.executePostResolutionInterceptor(t, n, "Single"), n;
+    }
+    throw new Error("Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.");
+  }, e.prototype.executePreResolutionInterceptor = function(t, r) {
+    var s, o;
+    if (this.interceptors.preResolution.has(t)) {
+      var n = [];
+      try {
+        for (var l = oe(this.interceptors.preResolution.getAll(t)), w = l.next(); !w.done; w = l.next()) {
+          var R = w.value;
+          R.options.frequency != "Once" && n.push(R), R.callback(t, r);
+        }
+      } catch (_) {
+        s = { error: _ };
+      } finally {
+        try {
+          w && !w.done && (o = l.return) && o.call(l);
+        } finally {
+          if (s) throw s.error;
+        }
+      }
+      this.interceptors.preResolution.setAll(t, n);
+    }
+  }, e.prototype.executePostResolutionInterceptor = function(t, r, s) {
+    var o, n;
+    if (this.interceptors.postResolution.has(t)) {
+      var l = [];
+      try {
+        for (var w = oe(this.interceptors.postResolution.getAll(t)), R = w.next(); !R.done; R = w.next()) {
+          var _ = R.value;
+          _.options.frequency != "Once" && l.push(_), _.callback(t, r, s);
+        }
+      } catch (S) {
+        o = { error: S };
+      } finally {
+        try {
+          R && !R.done && (n = w.return) && n.call(w);
+        } finally {
+          if (o) throw o.error;
+        }
+      }
+      this.interceptors.postResolution.setAll(t, l);
+    }
+  }, e.prototype.resolveRegistration = function(t, r) {
+    if (this.ensureNotDisposed(), t.options.lifecycle === D.ResolutionScoped && r.scopedResolutions.has(t))
+      return r.scopedResolutions.get(t);
+    var s = t.options.lifecycle === D.Singleton, o = t.options.lifecycle === D.ContainerScoped, n = s || o, l;
+    return fe(t.provider) ? l = t.provider.useValue : le(t.provider) ? l = n ? t.instance || (t.instance = this.resolve(t.provider.useToken, r)) : this.resolve(t.provider.useToken, r) : at(t.provider) ? l = n ? t.instance || (t.instance = this.construct(t.provider.useClass, r)) : this.construct(t.provider.useClass, r) : Oe(t.provider) ? l = t.provider.useFactory(this) : l = this.construct(t.provider, r), t.options.lifecycle === D.ResolutionScoped && r.scopedResolutions.set(t, l), l;
+  }, e.prototype.resolveAll = function(t, r, s) {
+    var o = this;
+    r === void 0 && (r = new ae()), s === void 0 && (s = !1), this.ensureNotDisposed();
+    var n = this.getAllRegistrations(t);
+    if (!n && Q(t)) {
+      if (s)
+        return [];
+      throw new Error('Attempted to resolve unregistered dependency token: "' + t.toString() + '"');
+    }
+    if (this.executePreResolutionInterceptor(t, "All"), n) {
+      var l = n.map(function(R) {
+        return o.resolveRegistration(R, r);
+      });
+      return this.executePostResolutionInterceptor(t, l, "All"), l;
+    }
+    var w = [this.construct(t, r)];
+    return this.executePostResolutionInterceptor(t, w, "All"), w;
+  }, e.prototype.isRegistered = function(t, r) {
+    return r === void 0 && (r = !1), this.ensureNotDisposed(), this._registry.has(t) || r && (this.parent || !1) && this.parent.isRegistered(t, !0);
+  }, e.prototype.reset = function() {
+    this.ensureNotDisposed(), this._registry.clear(), this.interceptors.preResolution.clear(), this.interceptors.postResolution.clear();
+  }, e.prototype.clearInstances = function() {
+    var t, r;
+    this.ensureNotDisposed();
+    try {
+      for (var s = oe(this._registry.entries()), o = s.next(); !o.done; o = s.next()) {
+        var n = ce(o.value, 2), l = n[0], w = n[1];
+        this._registry.setAll(l, w.filter(function(R) {
+          return !fe(R.provider);
+        }).map(function(R) {
+          return R.instance = void 0, R;
+        }));
+      }
+    } catch (R) {
+      t = { error: R };
+    } finally {
+      try {
+        o && !o.done && (r = s.return) && r.call(s);
+      } finally {
+        if (t) throw t.error;
+      }
+    }
+  }, e.prototype.createChildContainer = function() {
+    var t, r;
+    this.ensureNotDisposed();
+    var s = new e(this);
+    try {
+      for (var o = oe(this._registry.entries()), n = o.next(); !n.done; n = o.next()) {
+        var l = ce(n.value, 2), w = l[0], R = l[1];
+        R.some(function(_) {
+          var S = _.options;
+          return S.lifecycle === D.ContainerScoped;
+        }) && s._registry.setAll(w, R.map(function(_) {
+          return _.options.lifecycle === D.ContainerScoped ? {
+            provider: _.provider,
+            options: _.options
+          } : _;
+        }));
+      }
+    } catch (_) {
+      t = { error: _ };
+    } finally {
+      try {
+        n && !n.done && (r = o.return) && r.call(o);
+      } finally {
+        if (t) throw t.error;
+      }
+    }
+    return s;
+  }, e.prototype.beforeResolution = function(t, r, s) {
+    s === void 0 && (s = { frequency: "Always" }), this.interceptors.preResolution.set(t, {
+      callback: r,
+      options: s
+    });
+  }, e.prototype.afterResolution = function(t, r, s) {
+    s === void 0 && (s = { frequency: "Always" }), this.interceptors.postResolution.set(t, {
+      callback: r,
+      options: s
+    });
+  }, e.prototype.dispose = function() {
+    return Gt(this, void 0, void 0, function() {
+      var t;
+      return Vt(this, function(r) {
+        switch (r.label) {
+          case 0:
+            return this.disposed = !0, t = [], this.disposables.forEach(function(s) {
+              var o = s.dispose();
+              o && t.push(o);
+            }), [4, Promise.all(t)];
+          case 1:
+            return r.sent(), [2];
+        }
+      });
+    });
+  }, e.prototype.getRegistration = function(t) {
+    return this.isRegistered(t) ? this._registry.get(t) : this.parent ? this.parent.getRegistration(t) : null;
+  }, e.prototype.getAllRegistrations = function(t) {
+    return this.isRegistered(t) ? this._registry.getAll(t) : this.parent ? this.parent.getAllRegistrations(t) : null;
+  }, e.prototype.construct = function(t, r) {
+    var s = this;
+    if (t instanceof ut)
+      return t.createProxy(function(n) {
+        return s.resolve(n, r);
+      });
+    var o = (function() {
+      var n = lt.get(t);
+      if (!n || n.length === 0) {
+        if (t.length === 0)
+          return new t();
+        throw new Error('TypeInfo not known for "' + t.name + '"');
+      }
+      var l = n.map(s.resolveParams(r, t));
+      return new (t.bind.apply(t, q([void 0], l)))();
+    })();
+    return Kt(o) && this.disposables.add(o), o;
+  }, e.prototype.resolveParams = function(t, r) {
+    var s = this;
+    return function(o, n) {
+      var l, w, R;
+      try {
+        return Ut(o) ? Ke(o) ? o.multiple ? (l = s.resolve(o.transform)).transform.apply(l, q([s.resolveAll(o.token, new ae(), o.isOptional)], o.transformArgs)) : (w = s.resolve(o.transform)).transform.apply(w, q([s.resolve(o.token, t, o.isOptional)], o.transformArgs)) : o.multiple ? s.resolveAll(o.token, new ae(), o.isOptional) : s.resolve(o.token, t, o.isOptional) : Ke(o) ? (R = s.resolve(o.transform, t)).transform.apply(R, q([s.resolve(o.token, t)], o.transformArgs)) : s.resolve(o, t);
+      } catch (_) {
+        throw new Error(Xt(r, n, _));
+      }
+    };
+  }, e.prototype.ensureNotDisposed = function() {
+    if (this.disposed)
+      throw new Error("This container has been disposed, you cannot interact with a disposed container");
+  }, e;
+})(), ir = new nr();
+function W(e, t) {
+  var r = {
+    token: e,
+    multiple: !1,
+    isOptional: t
+  };
+  return ot(r);
+}
+function z(e) {
+  return function(t) {
+    lt.set(t, zt(t));
+  };
+}
+function ft(e, t) {
+  var r = {
+    token: e,
+    multiple: !0,
+    isOptional: t
+  };
+  return ot(r);
+}
+if (typeof Reflect > "u" || !Reflect.getMetadata)
+  throw new Error(`tsyringe requires a reflect polyfill. Please add 'import "reflect-metadata"' to the top of your entry point.`);
+var ue = { exports: {} }, et;
+function sr() {
+  if (et) return ue.exports;
+  et = 1;
+  var e = typeof Reflect == "object" ? Reflect : null, t = e && typeof e.apply == "function" ? e.apply : function(f, d, g) {
+    return Function.prototype.apply.call(f, d, g);
+  }, r;
+  e && typeof e.ownKeys == "function" ? r = e.ownKeys : Object.getOwnPropertySymbols ? r = function(f) {
+    return Object.getOwnPropertyNames(f).concat(Object.getOwnPropertySymbols(f));
+  } : r = function(f) {
+    return Object.getOwnPropertyNames(f);
+  };
+  function s(c) {
+    console && console.warn && console.warn(c);
+  }
+  var o = Number.isNaN || function(f) {
+    return f !== f;
+  };
+  function n() {
+    n.init.call(this);
+  }
+  ue.exports = n, ue.exports.once = J, n.EventEmitter = n, n.prototype._events = void 0, n.prototype._eventsCount = 0, n.prototype._maxListeners = void 0;
+  var l = 10;
+  function w(c) {
+    if (typeof c != "function")
+      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof c);
+  }
+  Object.defineProperty(n, "defaultMaxListeners", {
+    enumerable: !0,
+    get: function() {
+      return l;
+    },
+    set: function(c) {
+      if (typeof c != "number" || c < 0 || o(c))
+        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + c + ".");
+      l = c;
+    }
+  }), n.init = function() {
+    (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+  }, n.prototype.setMaxListeners = function(f) {
+    if (typeof f != "number" || f < 0 || o(f))
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + f + ".");
+    return this._maxListeners = f, this;
+  };
+  function R(c) {
+    return c._maxListeners === void 0 ? n.defaultMaxListeners : c._maxListeners;
+  }
+  n.prototype.getMaxListeners = function() {
+    return R(this);
+  }, n.prototype.emit = function(f) {
+    for (var d = [], g = 1; g < arguments.length; g++) d.push(arguments[g]);
+    var O = f === "error", x = this._events;
+    if (x !== void 0)
+      O = O && x.error === void 0;
+    else if (!O)
+      return !1;
+    if (O) {
+      var P;
+      if (d.length > 0 && (P = d[0]), P instanceof Error)
+        throw P;
+      var H = new Error("Unhandled error." + (P ? " (" + P.message + ")" : ""));
+      throw H.context = P, H;
+    }
+    var U = x[f];
+    if (U === void 0)
+      return !1;
+    if (typeof U == "function")
+      t(U, this, d);
+    else
+      for (var ie = U.length, ve = Z(U, ie), g = 0; g < ie; ++g)
+        t(ve[g], this, d);
+    return !0;
+  };
+  function _(c, f, d, g) {
+    var O, x, P;
+    if (w(d), x = c._events, x === void 0 ? (x = c._events = /* @__PURE__ */ Object.create(null), c._eventsCount = 0) : (x.newListener !== void 0 && (c.emit(
+      "newListener",
+      f,
+      d.listener ? d.listener : d
+    ), x = c._events), P = x[f]), P === void 0)
+      P = x[f] = d, ++c._eventsCount;
+    else if (typeof P == "function" ? P = x[f] = g ? [d, P] : [P, d] : g ? P.unshift(d) : P.push(d), O = R(c), O > 0 && P.length > O && !P.warned) {
+      P.warned = !0;
+      var H = new Error("Possible EventEmitter memory leak detected. " + P.length + " " + String(f) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+      H.name = "MaxListenersExceededWarning", H.emitter = c, H.type = f, H.count = P.length, s(H);
+    }
+    return c;
+  }
+  n.prototype.addListener = function(f, d) {
+    return _(this, f, d, !1);
+  }, n.prototype.on = n.prototype.addListener, n.prototype.prependListener = function(f, d) {
+    return _(this, f, d, !0);
+  };
+  function S() {
+    if (!this.fired)
+      return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+  }
+  function j(c, f, d) {
+    var g = { fired: !1, wrapFn: void 0, target: c, type: f, listener: d }, O = S.bind(g);
+    return O.listener = d, g.wrapFn = O, O;
+  }
+  n.prototype.once = function(f, d) {
+    return w(d), this.on(f, j(this, f, d)), this;
+  }, n.prototype.prependOnceListener = function(f, d) {
+    return w(d), this.prependListener(f, j(this, f, d)), this;
+  }, n.prototype.removeListener = function(f, d) {
+    var g, O, x, P, H;
+    if (w(d), O = this._events, O === void 0)
+      return this;
+    if (g = O[f], g === void 0)
+      return this;
+    if (g === d || g.listener === d)
+      --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete O[f], O.removeListener && this.emit("removeListener", f, g.listener || d));
+    else if (typeof g != "function") {
+      for (x = -1, P = g.length - 1; P >= 0; P--)
+        if (g[P] === d || g[P].listener === d) {
+          H = g[P].listener, x = P;
+          break;
+        }
+      if (x < 0)
+        return this;
+      x === 0 ? g.shift() : K(g, x), g.length === 1 && (O[f] = g[0]), O.removeListener !== void 0 && this.emit("removeListener", f, H || d);
+    }
+    return this;
+  }, n.prototype.off = n.prototype.removeListener, n.prototype.removeAllListeners = function(f) {
+    var d, g, O;
+    if (g = this._events, g === void 0)
+      return this;
+    if (g.removeListener === void 0)
+      return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : g[f] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete g[f]), this;
+    if (arguments.length === 0) {
+      var x = Object.keys(g), P;
+      for (O = 0; O < x.length; ++O)
+        P = x[O], P !== "removeListener" && this.removeAllListeners(P);
+      return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
+    }
+    if (d = g[f], typeof d == "function")
+      this.removeListener(f, d);
+    else if (d !== void 0)
+      for (O = d.length - 1; O >= 0; O--)
+        this.removeListener(f, d[O]);
+    return this;
+  };
+  function B(c, f, d) {
+    var g = c._events;
+    if (g === void 0)
+      return [];
+    var O = g[f];
+    return O === void 0 ? [] : typeof O == "function" ? d ? [O.listener || O] : [O] : d ? V(O) : Z(O, O.length);
+  }
+  n.prototype.listeners = function(f) {
+    return B(this, f, !0);
+  }, n.prototype.rawListeners = function(f) {
+    return B(this, f, !1);
+  }, n.listenerCount = function(c, f) {
+    return typeof c.listenerCount == "function" ? c.listenerCount(f) : G.call(c, f);
+  }, n.prototype.listenerCount = G;
+  function G(c) {
+    var f = this._events;
+    if (f !== void 0) {
+      var d = f[c];
+      if (typeof d == "function")
+        return 1;
+      if (d !== void 0)
+        return d.length;
+    }
+    return 0;
+  }
+  n.prototype.eventNames = function() {
+    return this._eventsCount > 0 ? r(this._events) : [];
+  };
+  function Z(c, f) {
+    for (var d = new Array(f), g = 0; g < f; ++g)
+      d[g] = c[g];
+    return d;
+  }
+  function K(c, f) {
+    for (; f + 1 < c.length; f++)
+      c[f] = c[f + 1];
+    c.pop();
+  }
+  function V(c) {
+    for (var f = new Array(c.length), d = 0; d < f.length; ++d)
+      f[d] = c[d].listener || c[d];
+    return f;
+  }
+  function J(c, f) {
+    return new Promise(function(d, g) {
+      function O(P) {
+        c.removeListener(f, x), g(P);
+      }
+      function x() {
+        typeof c.removeListener == "function" && c.removeListener("error", O), d([].slice.call(arguments));
+      }
+      ne(c, f, x, { once: !0 }), f !== "error" && re(c, O, { once: !0 });
+    });
+  }
+  function re(c, f, d) {
+    typeof c.on == "function" && ne(c, "error", f, d);
+  }
+  function ne(c, f, d, g) {
+    if (typeof c.on == "function")
+      g.once ? c.once(f, d) : c.on(f, d);
+    else if (typeof c.addEventListener == "function")
+      c.addEventListener(f, function O(x) {
+        g.once && c.removeEventListener(f, O), d(x);
+      });
+    else
+      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof c);
+  }
+  return ue.exports;
+}
+var or = sr(), ar = Object.getOwnPropertyDescriptor, ur = (e, t, r, s) => {
+  for (var o = s > 1 ? void 0 : s ? ar(t, r) : t, n = e.length - 1, l; n >= 0; n--)
+    (l = e[n]) && (o = l(o) || o);
+  return o;
+};
+let Re = class {
+  _emitter;
+  constructor() {
+    this._emitter = new or.EventEmitter();
+  }
+  /** Публикация события */
+  emit(e, t) {
+    this._emitter.emit(e, t);
+  }
+  /** Подписка на событие */
+  on(e, t) {
+    this._emitter.on(e, t);
+  }
+  /** Отписка от события */
+  off(e, t) {
+    this._emitter.off(e, t);
+  }
+};
+Re = ur([
+  z()
+], Re);
+var X = /* @__PURE__ */ ((e) => (e.SelectHover = "select.hover", e.SelectClick = "select.click", e))(X || {}), lr = Object.getOwnPropertyDescriptor, fr = (e, t, r, s) => {
+  for (var o = s > 1 ? void 0 : s ? lr(t, r) : t, n = e.length - 1, l; n >= 0; n--)
+    (l = e[n]) && (o = l(o) || o);
+  return o;
+}, tt = (e, t) => (r, s) => t(r, s, e);
+let Pe = class extends st {
   /**
    * Инициализация сцены редактора.
    * Создает сетку, оси координат и orbit-контроллер.
-   * @param canvas - HTMLCanvasElement для рендеринга
    */
-  constructor(e) {
-    super(e);
-    const t = new w(this.gl.gl, { size: 10, divisions: 10 });
-    t.position.y = -1e-3, t.setParent(this.scene), new x(this.gl.gl, { size: 6, symmetric: !0 }).setParent(this.scene), this.orbit = new P(this.camera, { element: this.canvas }), this.raycast = new I(), this.mouse = new L(), this.isEventListenersAdded = !1;
+  constructor(e, t) {
+    super(e), this._canvas = e, this._bus = t;
+    const r = new Tt(this.gl.gl, { size: 10, divisions: 10 });
+    r.position.y = -1e-3, r.setParent(this.scene), new At(this.gl.gl, { size: 6, symmetric: !0 }).setParent(this.scene), this._orbit = new Bt(this.camera, { element: this.canvas }), this._raycast = new kt(), this._mouse = new jt(), this._isEventListenersAdded = !1;
   }
+  /** Orbit-контроллер для управления камерой */
+  _orbit;
+  /** Raycast для подсветки моделей при наведении */
+  _raycast;
+  /** Курсор мыши для остлеживания наведения на 3D-модель */
+  _mouse;
+  /** Были ли зарегистрированы обработчики событий для мыши */
+  _isEventListenersAdded;
   /**
    * Обновление состояния рендерера.
    */
   update() {
-    this.orbit?.update();
+    this._orbit?.update();
   }
   /**
    * Метод для добавления фигуры.
    * Настройка raycast.
-   * @param figure Данные фигуры: position, normal, uv
+   * @param figure - Данные фигуры: position, normal, uv
    */
   addFigure(e) {
     const t = super.addFigure(e);
     if (t.geometry) {
-      const i = t.geometry.constructor.name;
-      t.geometry.raycast = i.includes("Sphere") ? "sphere" : "box";
+      const r = t.geometry.constructor.name;
+      t.geometry.raycast = r.includes("Sphere") ? "sphere" : "box";
     }
-    return t.isHit = !1, t.onBeforeRender(({ mesh: i }) => {
-      this.updateHitUniform(i);
-    }), this.isEventListenersAdded || this.initMouseListeners(), t;
+    return this._isEventListenersAdded || this.initMouseListeners(), t;
   }
   /**
-   * Обновление uniform uHit для конкретной 3D-модели
+   * Устанавливает callback, который будет вызываться перед рендером конкретного меша.
+   *
+   * @param mesh - Меш, для которого нужно задать callback.
+   * @param f - Функция обратного вызова, выполняемая перед рендером меша.
+   * @internal
    */
-  updateHitUniform(e) {
-    this.program.uniforms.uHit.value = e.isHit ? 1 : 0;
+  setMeshBeforeRender(e, t) {
+    e.onBeforeRender(t);
   }
   /**
    * Инициализация обработчиков мыши для raycast
    */
   initMouseListeners() {
-    document.addEventListener("mousemove", this.handleMouseMove, !1), this.isEventListenersAdded = !0;
+    document.addEventListener("mousemove", this._handleMouseMove, !1), document.addEventListener("click", this._handleMouseClick, !1), this._isEventListenersAdded = !0;
   }
   /**
    * Обработчик движения мыши
    */
-  handleMouseMove = (e) => {
-    if (this.orbit.isInteracting) return;
-    this.mouse.set(2 * (e.x / this.gl.width) - 1, 2 * (1 - e.y / this.gl.height) - 1), this.raycast.castMouse(this.camera, this.mouse), this.meshes.forEach((i) => i.isHit = !1), this.raycast.intersectBounds(this.meshes).forEach((i) => i.isHit = !0);
+  _handleMouseMove = (e) => {
+    this._processRaycastEvent(e, X.SelectHover, !0);
   };
+  /**
+   * Обработчик клика мыши
+   */
+  _handleMouseClick = (e) => {
+    this._processRaycastEvent(e, X.SelectClick, !1);
+  };
+  /**
+   * Универсальная логика raycast-события
+   */
+  _processRaycastEvent(e, t, r) {
+    if (this._orbit.isInteracting) return;
+    this._mouse.set(2 * (e.x / this.gl.width) - 1, 2 * (1 - e.y / this.gl.height) - 1), this._raycast.castMouse(this.camera, this._mouse), r && this.meshes.forEach((n) => n.isHit = !1);
+    const s = this._raycast.intersectBounds(this.meshes), o = s.length ? s[0] : null;
+    this._bus.emit(t, o ? { mesh: o } : null), r && s.forEach((n) => n.isHit = !0);
+  }
   /** Деструктор */
   destroy() {
-    this.isEventListenersAdded && (window.removeEventListener("mousemove", this.handleMouseMove, !1), this.isEventListenersAdded = !1), this.orbit = null, this.raycast = null, this.mouse = null, super.destroy();
+    this._isEventListenersAdded && (document.removeEventListener("mousemove", this._handleMouseMove, !1), document.removeEventListener("click", this._handleMouseClick, !1), this._isEventListenersAdded = !1), this._orbit.destroy(), this._orbit = null, this._raycast = null, this._mouse = null, super.destroy();
   }
-}
-class z extends u {
+};
+Pe = fr([
+  z(),
+  tt(0, W("Canvas")),
+  tt(1, W("EventBus"))
+], Pe);
+class Ir extends st {
   /** Orbit-контроллер для управления камерой */
-  orbit;
+  _orbit;
   /**
    * Инициализация сцены предпросмотра.
    * @param canvas - HTMLCanvasElement для рендеринга
    */
-  constructor(e) {
-    super(e), this.orbit = new c(this.camera, {
+  constructor(t) {
+    super(t), this._orbit = new it(this.camera, {
       element: this.canvas,
-      target: new E(0, 0, 0),
+      target: new Dt(0, 0, 0),
       minPolarAngle: Math.PI / 2,
       maxPolarAngle: Math.PI / 2,
       enableRotate: !0,
@@ -205,10 +1916,10 @@ class z extends u {
    * Обновление состояния рендерера.
    */
   update() {
-    this.orbit?.update();
+    this._orbit?.update();
   }
 }
-class A {
+class cr {
   /** Тип фигуры */
   type;
   /** Позиции вершин */
@@ -223,82 +1934,323 @@ class A {
    * Создаёт новую фигуру
    * @param data - исходные данные фигуры
    */
-  constructor(e) {
-    this.type = e.type, this.position = e.position, this.normal = e.normal ?? [], this.uv = e.uv ?? [], this.material = e.material;
+  constructor(t) {
+    this.type = t.type, this.position = t.position, this.normal = t.normal ?? [], this.uv = t.uv ?? [], this.material = t.material;
   }
 }
-var d = /* @__PURE__ */ ((s) => (s[s.Cube = 0] = "Cube", s[s.Sphere = 1] = "Sphere", s[s.Plane = 2] = "Plane", s[s.Cylinder = 3] = "Cylinder", s[s.Custom = 4] = "Custom", s))(d || {});
-class C {
+var ct = /* @__PURE__ */ ((e) => (e[e.Cube = 0] = "Cube", e[e.Sphere = 1] = "Sphere", e[e.Plane = 2] = "Plane", e[e.Cylinder = 3] = "Cylinder", e[e.Custom = 4] = "Custom", e))(ct || {}), te = /* @__PURE__ */ ((e) => (e.Plane = "plane", e.Wireframe = "wireframe", e.Texture = "texture", e))(te || {}), de = /* @__PURE__ */ ((e) => (e.Mesh = "mesh", e.Face = "face", e.Edge = "edge", e.Vertex = "vertex", e))(de || {});
+class Lr {
   /** Позиции вершин */
-  positions = [];
+  _positions = [];
   /** Нормали вершин */
-  normals = [];
+  _normals = [];
   /** UV-координаты (опционально) */
-  uvs = [];
+  _uvs = [];
   // Временные поля для парсинга файла
-  tmpPositions = [];
-  tmpNormals = [];
-  tmpUVs = [];
+  _tmpPositions = [];
+  _tmpNormals = [];
+  _tmpUVs = [];
   /**
    * Загружает OBJ-модель в Figure
-   * @param objContent Строка содержимого .obj файла
+   * @param objContent - Строка содержимого .obj файла
    */
-  load(e) {
-    const t = e.split(`
+  load(t) {
+    const r = t.split(`
 `);
-    for (const a of t) {
-      if (!a.trim() || a.startsWith("#")) continue;
-      const r = a.trim().split(/\s+/);
-      switch (r[0]) {
+    for (const o of r) {
+      if (!o.trim() || o.startsWith("#")) continue;
+      const n = o.trim().split(/\s+/);
+      switch (n[0]) {
         case "v":
-          this.tmpPositions.push(r.slice(1).map(Number));
+          this._tmpPositions.push(n.slice(1).map(Number));
           break;
         case "vn":
-          this.tmpNormals.push(r.slice(1).map(Number));
+          this._tmpNormals.push(n.slice(1).map(Number));
           break;
         case "vt":
-          this.tmpUVs.push(r.slice(1).map(Number));
+          this._tmpUVs.push(n.slice(1).map(Number));
           break;
         case "f":
-          this.processFaceLine(r);
+          this.processFaceLine(n);
           break;
       }
     }
-    const i = {
-      type: d.Custom,
-      position: this.positions,
-      ...this.normals.length > 0 && { normal: this.normals },
-      ...this.uvs.length > 0 && { uv: this.uvs }
+    const s = {
+      type: ct.Custom,
+      position: this._positions,
+      ...this._normals.length > 0 && { normal: this._normals },
+      ...this._uvs.length > 0 && { uv: this._uvs }
     };
-    return new A(i);
+    return new cr(s);
   }
   /**
    * Обрабатывает строку face (f) и разворачивает индексы в массивы для рендеринга
    */
-  processFaceLine(e) {
-    for (let t = 1; t < e.length; t++) {
-      const i = e[t];
-      if (!i) continue;
-      const [a, r, o] = i.split("/"), h = a ? parseInt(a, 10) : void 0, l = r ? parseInt(r, 10) : void 0, m = o ? parseInt(o, 10) : void 0;
-      if (h !== void 0) {
-        const n = this.tmpPositions[h - 1];
-        n && this.positions.push(...n);
-      }
-      if (l !== void 0) {
-        const n = this.tmpUVs[l - 1];
-        n && this.uvs.push(...n);
-      }
-      if (m !== void 0) {
-        const n = this.tmpNormals[m - 1];
-        n && this.normals.push(...n);
+  processFaceLine(t) {
+    for (let r = 1; r < t.length; r++) {
+      const s = t[r];
+      if (!s) continue;
+      const [o, n, l] = s.split("/"), w = o ? parseInt(o, 10) : void 0, R = n ? parseInt(n, 10) : void 0, _ = l ? parseInt(l, 10) : void 0;
+      if (w !== void 0) {
+        const S = this._tmpPositions[w - 1];
+        S && this._positions.push(...S);
+      }
+      if (R !== void 0) {
+        const S = this._tmpUVs[R - 1];
+        S && this._uvs.push(...S);
       }
+      if (_ !== void 0) {
+        const S = this._tmpNormals[_ - 1];
+        S && this._normals.push(...S);
+      }
+    }
+  }
+}
+var hr = Object.getOwnPropertyDescriptor, dr = (e, t, r, s) => {
+  for (var o = s > 1 ? void 0 : s ? hr(t, r) : t, n = e.length - 1, l; n >= 0; n--)
+    (l = e[n]) && (o = l(o) || o);
+  return o;
+}, vr = (e, t) => (r, s) => t(r, s, e);
+let Ee = class {
+  /** Текущий режим отображения */
+  _currentMode = te.Plane;
+  /** Хендлеры, которые управляют отображением */
+  _handlers;
+  constructor(e) {
+    this._handlers = new Map(e.map((t) => [t.mode, t]));
+  }
+  /** Установка режима отображения */
+  manage(e) {
+    e !== this._currentMode && (this._handlers.get(this._currentMode)?.rollback(), e !== te.Plane && this._handlers.get(e)?.handle(), this._currentMode = e);
+  }
+  /** Освобождение ресурсов */
+  destroy() {
+    this._handlers && this._handlers.clear(), this._currentMode = te.Plane;
+  }
+};
+Ee = dr([
+  z(),
+  vr(0, ft("IDisplayHandler"))
+], Ee);
+var he = /* @__PURE__ */ ((e) => (e.Hover = "hover", e.Click = "click", e))(he || {}), pr = Object.getOwnPropertyDescriptor, yr = (e, t, r, s) => {
+  for (var o = s > 1 ? void 0 : s ? pr(t, r) : t, n = e.length - 1, l; n >= 0; n--)
+    (l = e[n]) && (o = l(o) || o);
+  return o;
+}, rt = (e, t) => (r, s) => t(r, s, e);
+let Ce = class {
+  constructor(e, t) {
+    this._eventBus = e, this._handlers = new Map(t.map((r) => [r.mode, r])), this._eventBus.on(X.SelectHover, this._onHover), this._eventBus.on(X.SelectClick, this._onClick);
+  }
+  /** Текущий режим выборки */
+  _currentMode = de.Mesh;
+  /** Хендлеры, которые управляют выборкой */
+  _handlers;
+  manage(e) {
+    e !== this._currentMode && (this._handlers.get(this._currentMode)?.rollback(), this._currentMode = e);
+  }
+  /** Обработчик события наведения на модель */
+  _onHover = (e) => {
+    if (!e) return;
+    this._handlers.get(this._currentMode)?.handle(e, he.Hover);
+  };
+  /** Обработчик события клика на модель */
+  _onClick = (e) => {
+    if (!e) return;
+    this._handlers.get(this._currentMode)?.handle(e, he.Click);
+  };
+  destroy() {
+    this._eventBus.off(X.SelectHover, this._onHover);
+  }
+};
+Ce = yr([
+  z(),
+  rt(0, W("EventBus")),
+  rt(1, ft("ISelectHandler"))
+], Ce);
+var _r = Object.getOwnPropertyDescriptor, mr = (e, t, r, s) => {
+  for (var o = s > 1 ? void 0 : s ? _r(t, r) : t, n = e.length - 1, l; n >= 0; n--)
+    (l = e[n]) && (o = l(o) || o);
+  return o;
+}, gr = (e, t) => (r, s) => t(r, s, e);
+let Se = class {
+  constructor(e) {
+    this._api = e, this._wireMeshes = [], this._context = this._api.getContext(), this._wireMeshProgram = new Ht(this._context);
+  }
+  /** Режим отображения */
+  mode = te.Wireframe;
+  /** Wireframe-модели для добавленных на сцену объектов */
+  _wireMeshes;
+  /** Настройки рендеринга для режима wireframe */
+  _wireMeshProgram;
+  /** WebGl контекст */
+  _context;
+  /**
+   * Применяет wireframe-режим к сцене.
+   */
+  handle() {
+    const e = this._api.getMeshes();
+    this.createWireMeshes(e), this._api.removeMeshes(e), this._api.addMeshes(this._wireMeshes);
+  }
+  /**
+   * Отменяет wireframe-режим у сцены.
+   */
+  rollback() {
+    const e = this._api.getMeshes();
+    this._api.removeMeshes(this._wireMeshes), this._api.addMeshes(e);
+  }
+  /**
+   * Освобождает ресурсы хендлера, удаляет wireframe-модели со сцены.
+   */
+  destroy() {
+    this._wireMeshes && (this._wireMeshes.length = 0, this._wireMeshes = []);
+  }
+  /**
+   * Создание wireframe-моделей для фигур на сцене.
+   */
+  createWireMeshes(e) {
+    for (const t of e) {
+      const r = new Nt(this._context, {
+        geometry: t.geometry,
+        program: this._wireMeshProgram
+      });
+      this._wireMeshes.push(r);
     }
   }
+};
+Se = mr([
+  z(),
+  gr(0, W("RendererApi"))
+], Se);
+var wr = Object.getOwnPropertyDescriptor, Mr = (e, t, r, s) => {
+  for (var o = s > 1 ? void 0 : s ? wr(t, r) : t, n = e.length - 1, l; n >= 0; n--)
+    (l = e[n]) && (o = l(o) || o);
+  return o;
+}, br = (e, t) => (r, s) => t(r, s, e);
+let xe = class {
+  constructor(e) {
+    this._api = e, this._program = e.getProgram(), this._selectedMesh = null;
+  }
+  /** Режим выборки */
+  mode = de.Mesh;
+  /** Текущая программа для рендеринга фигуры*/
+  _program;
+  /** Выбранная фигура */
+  _selectedMesh;
+  handle(e, t) {
+    if (!e) return;
+    const { mesh: r } = e;
+    t === he.Hover ? this._api.setMeshBeforeRender(r, () => this._onHover(r)) : this._api.setMeshBeforeRender(r, () => this._onClick(r));
+  }
+  /** Обработчик события при наведении курсора мыши на модель */
+  _onHover = (e) => {
+    e.program.uniforms.uHit.value = e.isHit ? 1 : 0;
+  };
+  /** Обработчик события при клике на модель */
+  _onClick = (e) => {
+    this._selectedMesh && this._selectedMesh.program?.uniforms.uSelected && (this._selectedMesh.program.uniforms.uSelected.value = 0), this._selectedMesh = e, e.program?.uniforms.uSelected && (e.program.uniforms.uSelected.value = 1), console.log(`Selected mesh: ${e.id}`);
+  };
+  /** Выключение подсветки у моделей */
+  rollback() {
+    this._program.uniforms.uHit.value = 0;
+  }
+  destroy() {
+    this.rollback();
+  }
+};
+xe = Mr([
+  z(),
+  br(0, W("RendererApi"))
+], xe);
+var Or = Object.getOwnPropertyDescriptor, Rr = (e, t, r, s) => {
+  for (var o = s > 1 ? void 0 : s ? Or(t, r) : t, n = e.length - 1, l; n >= 0; n--)
+    (l = e[n]) && (o = l(o) || o);
+  return o;
+}, Pr = (e, t) => (r, s) => t(r, s, e);
+let Ie = class {
+  constructor(e) {
+    this._renderer = e;
+  }
+  addMesh(e) {
+    this._renderer.addMesh(e);
+  }
+  addMeshes(e) {
+    for (const t of e)
+      this._renderer.addMesh(t);
+  }
+  removeMesh(e) {
+    this._renderer.removeMesh(e);
+  }
+  removeMeshes(e) {
+    for (const t of e)
+      this._renderer.removeMesh(t);
+  }
+  getMeshes() {
+    return this._renderer.getMeshes();
+  }
+  getContext() {
+    return this._renderer.getContext();
+  }
+  getProgram() {
+    return this._renderer.getProgram();
+  }
+  setMeshBeforeRender(e, t) {
+    this._renderer.setMeshBeforeRender(e, t);
+  }
+};
+Ie = Rr([
+  z(),
+  Pr(0, W("EditorRenderer"))
+], Ie);
+var Er = Object.getOwnPropertyDescriptor, Cr = (e, t, r, s) => {
+  for (var o = s > 1 ? void 0 : s ? Er(t, r) : t, n = e.length - 1, l; n >= 0; n--)
+    (l = e[n]) && (o = l(o) || o);
+  return o;
+}, ge = (e, t) => (r, s) => t(r, s, e);
+let Le = class {
+  constructor(e, t, r) {
+    this._displayManager = e, this._selectManager = t, this._renderer = r, t.manage(de.Mesh);
+  }
+  setDisplayMode(e) {
+    this._displayManager.manage(e);
+  }
+  setSelectMode(e) {
+    this._selectManager.manage(e);
+  }
+  resizeRenderer() {
+    this._renderer.resize();
+  }
+  updateRenderer() {
+    this._renderer.loop();
+  }
+  addFigure(e) {
+    this._renderer.addFigure(e);
+  }
+  destroy() {
+    this._displayManager.destroy(), this._selectManager.destroy(), this._renderer.destroy();
+  }
+};
+Le = Cr([
+  z(),
+  ge(0, W("IDisplayManager")),
+  ge(1, W("ISelectManager")),
+  ge(2, W("EditorRenderer"))
+], Le);
+let nt = !1;
+const F = ir.createChildContainer();
+function Sr(e) {
+  return nt || (F.registerInstance("Canvas", e), F.registerSingleton("EventBus", Re), F.registerSingleton("EditorRenderer", Pe), F.registerSingleton("RendererApi", Ie), F.registerSingleton("IDisplayHandler", Se), F.registerSingleton("ISelectHandler", xe), F.registerSingleton("IDisplayManager", Ee), F.registerSingleton("ISelectManager", Ce), F.registerSingleton("EditorHub", Le), nt = !0), F;
+}
+function Tr(e) {
+  return Sr(e).resolve("EditorHub");
 }
 export {
-  F as EditorRenderer,
-  C as ObjLoader,
-  z as PreviewRenderer,
-  u as Renderer,
-  M as createProgram
+  Le as EditorHub,
+  Wt as EditorMesh,
+  Pe as EditorRenderer,
+  Re as EventBus,
+  X as EventTopics,
+  Lr as ObjLoader,
+  Ir as PreviewRenderer,
+  st as Renderer,
+  Tr as createAppHub
 };