@planara/core 1.4.9 → 1.5.0

package/dist/index.es.js

@@ -1,5 +1,823 @@
-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) {
+import { Program as ht, Renderer as dt, Transform as pt, Camera as vt, Geometry as yt, Mesh as gt, Orbit as De, GridHelper as mt, AxesHelper as wt, Raycast as Mt, Vec2 as _t, Vec3 as bt, NormalProgram as Pt, WireMesh as Rt } from "ogl";
+var Ie = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Ce = {};
+/*! *****************************************************************************
+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 Te;
+function Ot() {
+  if (Te) return Ce;
+  Te = 1;
+  var t;
+  return (function(e) {
+    (function(r) {
+      var s = typeof globalThis == "object" ? globalThis : typeof Ie == "object" ? Ie : typeof self == "object" ? self : typeof this == "object" ? this : w(), a = o(e);
+      typeof s.Reflect < "u" && (a = o(s.Reflect, a)), r(a, s), typeof s.Reflect > "u" && (s.Reflect = e);
+      function o(v, b) {
+        return function(C, N) {
+          Object.defineProperty(v, C, { configurable: !0, writable: !0, value: N }), b && b(C, N);
+        };
+      }
+      function f() {
+        try {
+          return Function("return this;")();
+        } catch {
+        }
+      }
+      function m() {
+        try {
+          return (0, eval)("(function() { return this; })()");
+        } catch {
+        }
+      }
+      function w() {
+        return f() || m();
+      }
+    })(function(r, s) {
+      var a = Object.prototype.hasOwnProperty, o = typeof Symbol == "function", f = o && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", m = o && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", w = typeof Object.create == "function", v = { __proto__: [] } instanceof Array, b = !w && !v, C = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: w ? function() {
+          return K(/* @__PURE__ */ Object.create(null));
+        } : v ? function() {
+          return K({ __proto__: null });
+        } : function() {
+          return K({});
+        },
+        has: b ? function(n, i) {
+          return a.call(n, i);
+        } : function(n, i) {
+          return i in n;
+        },
+        get: b ? function(n, i) {
+          return a.call(n, i) ? n[i] : void 0;
+        } : function(n, i) {
+          return n[i];
+        }
+      }, N = Object.getPrototypeOf(Function), H = typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : ot(), Z = typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : ut(), J = typeof WeakMap == "function" ? WeakMap : lt(), D = o ? Symbol.for("@reflect-metadata:registry") : void 0, V = it(), ce = st(V);
+      function Le(n, i, u, l) {
+        if (g(u)) {
+          if (!Me(n))
+            throw new TypeError();
+          if (!_e(i))
+            throw new TypeError();
+          return Ye(n, i);
+        } else {
+          if (!Me(n))
+            throw new TypeError();
+          if (!E(i))
+            throw new TypeError();
+          if (!E(l) && !g(l) && !k(l))
+            throw new TypeError();
+          return k(l) && (l = void 0), u = x(u), Qe(n, i, u, l);
+        }
+      }
+      r("decorate", Le);
+      function Ve(n, i) {
+        function u(l, y) {
+          if (!E(l))
+            throw new TypeError();
+          if (!g(y) && !rt(y))
+            throw new TypeError();
+          ve(n, i, l, y);
+        }
+        return u;
+      }
+      r("metadata", Ve);
+      function We(n, i, u, l) {
+        if (!E(u))
+          throw new TypeError();
+        return g(l) || (l = x(l)), ve(n, i, u, l);
+      }
+      r("defineMetadata", We);
+      function ze(n, i, u) {
+        if (!E(i))
+          throw new TypeError();
+        return g(u) || (u = x(u)), he(n, i, u);
+      }
+      r("hasMetadata", ze);
+      function Ue(n, i, u) {
+        if (!E(i))
+          throw new TypeError();
+        return g(u) || (u = x(u)), Y(n, i, u);
+      }
+      r("hasOwnMetadata", Ue);
+      function $e(n, i, u) {
+        if (!E(i))
+          throw new TypeError();
+        return g(u) || (u = x(u)), de(n, i, u);
+      }
+      r("getMetadata", $e);
+      function qe(n, i, u) {
+        if (!E(i))
+          throw new TypeError();
+        return g(u) || (u = x(u)), pe(n, i, u);
+      }
+      r("getOwnMetadata", qe);
+      function Be(n, i) {
+        if (!E(n))
+          throw new TypeError();
+        return g(i) || (i = x(i)), ye(n, i);
+      }
+      r("getMetadataKeys", Be);
+      function Ze(n, i) {
+        if (!E(n))
+          throw new TypeError();
+        return g(i) || (i = x(i)), ge(n, i);
+      }
+      r("getOwnMetadataKeys", Ze);
+      function Je(n, i, u) {
+        if (!E(i))
+          throw new TypeError();
+        if (g(u) || (u = x(u)), !E(i))
+          throw new TypeError();
+        g(u) || (u = x(u));
+        var l = F(
+          i,
+          u,
+          /*Create*/
+          !1
+        );
+        return g(l) ? !1 : l.OrdinaryDeleteMetadata(n, i, u);
+      }
+      r("deleteMetadata", Je);
+      function Ye(n, i) {
+        for (var u = n.length - 1; u >= 0; --u) {
+          var l = n[u], y = l(i);
+          if (!g(y) && !k(y)) {
+            if (!_e(y))
+              throw new TypeError();
+            i = y;
+          }
+        }
+        return i;
+      }
+      function Qe(n, i, u, l) {
+        for (var y = n.length - 1; y >= 0; --y) {
+          var R = n[y], S = R(i, u, l);
+          if (!g(S) && !k(S)) {
+            if (!E(S))
+              throw new TypeError();
+            l = S;
+          }
+        }
+        return l;
+      }
+      function he(n, i, u) {
+        var l = Y(n, i, u);
+        if (l)
+          return !0;
+        var y = X(i);
+        return k(y) ? !1 : he(n, y, u);
+      }
+      function Y(n, i, u) {
+        var l = F(
+          i,
+          u,
+          /*Create*/
+          !1
+        );
+        return g(l) ? !1 : we(l.OrdinaryHasOwnMetadata(n, i, u));
+      }
+      function de(n, i, u) {
+        var l = Y(n, i, u);
+        if (l)
+          return pe(n, i, u);
+        var y = X(i);
+        if (!k(y))
+          return de(n, y, u);
+      }
+      function pe(n, i, u) {
+        var l = F(
+          i,
+          u,
+          /*Create*/
+          !1
+        );
+        if (!g(l))
+          return l.OrdinaryGetOwnMetadata(n, i, u);
+      }
+      function ve(n, i, u, l) {
+        var y = F(
+          u,
+          l,
+          /*Create*/
+          !0
+        );
+        y.OrdinaryDefineOwnMetadata(n, i, u, l);
+      }
+      function ye(n, i) {
+        var u = ge(n, i), l = X(n);
+        if (l === null)
+          return u;
+        var y = ye(l, i);
+        if (y.length <= 0)
+          return u;
+        if (u.length <= 0)
+          return y;
+        for (var R = new Z(), S = [], M = 0, c = u; M < c.length; M++) {
+          var h = c[M], d = R.has(h);
+          d || (R.add(h), S.push(h));
+        }
+        for (var p = 0, _ = y; p < _.length; p++) {
+          var h = _[p], d = R.has(h);
+          d || (R.add(h), S.push(h));
+        }
+        return S;
+      }
+      function ge(n, i) {
+        var u = F(
+          n,
+          i,
+          /*create*/
+          !1
+        );
+        return u ? u.OrdinaryOwnMetadataKeys(n, i) : [];
+      }
+      function me(n) {
+        if (n === null)
+          return 1;
+        switch (typeof n) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return n === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function g(n) {
+        return n === void 0;
+      }
+      function k(n) {
+        return n === null;
+      }
+      function Xe(n) {
+        return typeof n == "symbol";
+      }
+      function E(n) {
+        return typeof n == "object" ? n !== null : typeof n == "function";
+      }
+      function Ke(n, i) {
+        switch (me(n)) {
+          case 0:
+            return n;
+          case 1:
+            return n;
+          case 2:
+            return n;
+          case 3:
+            return n;
+          case 4:
+            return n;
+          case 5:
+            return n;
+        }
+        var u = "string", l = be(n, f);
+        if (l !== void 0) {
+          var y = l.call(n, u);
+          if (E(y))
+            throw new TypeError();
+          return y;
+        }
+        return et(n);
+      }
+      function et(n, i) {
+        var u, l, y;
+        {
+          var R = n.toString;
+          if (W(R)) {
+            var l = R.call(n);
+            if (!E(l))
+              return l;
+          }
+          var u = n.valueOf;
+          if (W(u)) {
+            var l = u.call(n);
+            if (!E(l))
+              return l;
+          }
+        }
+        throw new TypeError();
+      }
+      function we(n) {
+        return !!n;
+      }
+      function tt(n) {
+        return "" + n;
+      }
+      function x(n) {
+        var i = Ke(n);
+        return Xe(i) ? i : tt(i);
+      }
+      function Me(n) {
+        return Array.isArray ? Array.isArray(n) : n instanceof Object ? n instanceof Array : Object.prototype.toString.call(n) === "[object Array]";
+      }
+      function W(n) {
+        return typeof n == "function";
+      }
+      function _e(n) {
+        return typeof n == "function";
+      }
+      function rt(n) {
+        switch (me(n)) {
+          case 3:
+            return !0;
+          case 4:
+            return !0;
+          default:
+            return !1;
+        }
+      }
+      function Q(n, i) {
+        return n === i || n !== n && i !== i;
+      }
+      function be(n, i) {
+        var u = n[i];
+        if (u != null) {
+          if (!W(u))
+            throw new TypeError();
+          return u;
+        }
+      }
+      function Pe(n) {
+        var i = be(n, m);
+        if (!W(i))
+          throw new TypeError();
+        var u = i.call(n);
+        if (!E(u))
+          throw new TypeError();
+        return u;
+      }
+      function Re(n) {
+        return n.value;
+      }
+      function Oe(n) {
+        var i = n.next();
+        return i.done ? !1 : i;
+      }
+      function Ee(n) {
+        var i = n.return;
+        i && i.call(n);
+      }
+      function X(n) {
+        var i = Object.getPrototypeOf(n);
+        if (typeof n != "function" || n === N || i !== N)
+          return i;
+        var u = n.prototype, l = u && Object.getPrototypeOf(u);
+        if (l == null || l === Object.prototype)
+          return i;
+        var y = l.constructor;
+        return typeof y != "function" || y === n ? i : y;
+      }
+      function nt() {
+        var n;
+        !g(D) && typeof s.Reflect < "u" && !(D in s.Reflect) && typeof s.Reflect.defineMetadata == "function" && (n = at(s.Reflect));
+        var i, u, l, y = new J(), R = {
+          registerProvider: S,
+          getProvider: c,
+          setProvider: d
+        };
+        return R;
+        function S(p) {
+          if (!Object.isExtensible(R))
+            throw new Error("Cannot add provider to a frozen registry.");
+          switch (!0) {
+            case n === p:
+              break;
+            case g(i):
+              i = p;
+              break;
+            case i === p:
+              break;
+            case g(u):
+              u = p;
+              break;
+            case u === p:
+              break;
+            default:
+              l === void 0 && (l = new Z()), l.add(p);
+              break;
+          }
+        }
+        function M(p, _) {
+          if (!g(i)) {
+            if (i.isProviderFor(p, _))
+              return i;
+            if (!g(u)) {
+              if (u.isProviderFor(p, _))
+                return i;
+              if (!g(l))
+                for (var P = Pe(l); ; ) {
+                  var O = Oe(P);
+                  if (!O)
+                    return;
+                  var T = Re(O);
+                  if (T.isProviderFor(p, _))
+                    return Ee(P), T;
+                }
+            }
+          }
+          if (!g(n) && n.isProviderFor(p, _))
+            return n;
+        }
+        function c(p, _) {
+          var P = y.get(p), O;
+          return g(P) || (O = P.get(_)), g(O) && (O = M(p, _), g(O) || (g(P) && (P = new H(), y.set(p, P)), P.set(_, O))), O;
+        }
+        function h(p) {
+          if (g(p))
+            throw new TypeError();
+          return i === p || u === p || !g(l) && l.has(p);
+        }
+        function d(p, _, P) {
+          if (!h(P))
+            throw new Error("Metadata provider not registered.");
+          var O = c(p, _);
+          if (O !== P) {
+            if (!g(O))
+              return !1;
+            var T = y.get(p);
+            g(T) && (T = new H(), y.set(p, T)), T.set(_, P);
+          }
+          return !0;
+        }
+      }
+      function it() {
+        var n;
+        return !g(D) && E(s.Reflect) && Object.isExtensible(s.Reflect) && (n = s.Reflect[D]), g(n) && (n = nt()), !g(D) && E(s.Reflect) && Object.isExtensible(s.Reflect) && Object.defineProperty(s.Reflect, D, {
+          enumerable: !1,
+          configurable: !1,
+          writable: !1,
+          value: n
+        }), n;
+      }
+      function st(n) {
+        var i = new J(), u = {
+          isProviderFor: function(h, d) {
+            var p = i.get(h);
+            return g(p) ? !1 : p.has(d);
+          },
+          OrdinaryDefineOwnMetadata: S,
+          OrdinaryHasOwnMetadata: y,
+          OrdinaryGetOwnMetadata: R,
+          OrdinaryOwnMetadataKeys: M,
+          OrdinaryDeleteMetadata: c
+        };
+        return V.registerProvider(u), u;
+        function l(h, d, p) {
+          var _ = i.get(h), P = !1;
+          if (g(_)) {
+            if (!p)
+              return;
+            _ = new H(), i.set(h, _), P = !0;
+          }
+          var O = _.get(d);
+          if (g(O)) {
+            if (!p)
+              return;
+            if (O = new H(), _.set(d, O), !n.setProvider(h, d, u))
+              throw _.delete(d), P && i.delete(h), new Error("Wrong provider for target.");
+          }
+          return O;
+        }
+        function y(h, d, p) {
+          var _ = l(
+            d,
+            p,
+            /*Create*/
+            !1
+          );
+          return g(_) ? !1 : we(_.has(h));
+        }
+        function R(h, d, p) {
+          var _ = l(
+            d,
+            p,
+            /*Create*/
+            !1
+          );
+          if (!g(_))
+            return _.get(h);
+        }
+        function S(h, d, p, _) {
+          var P = l(
+            p,
+            _,
+            /*Create*/
+            !0
+          );
+          P.set(h, d);
+        }
+        function M(h, d) {
+          var p = [], _ = l(
+            h,
+            d,
+            /*Create*/
+            !1
+          );
+          if (g(_))
+            return p;
+          for (var P = _.keys(), O = Pe(P), T = 0; ; ) {
+            var Se = Oe(O);
+            if (!Se)
+              return p.length = T, p;
+            var ft = Re(Se);
+            try {
+              p[T] = ft;
+            } catch (ct) {
+              try {
+                Ee(O);
+              } finally {
+                throw ct;
+              }
+            }
+            T++;
+          }
+        }
+        function c(h, d, p) {
+          var _ = l(
+            d,
+            p,
+            /*Create*/
+            !1
+          );
+          if (g(_) || !_.delete(h))
+            return !1;
+          if (_.size === 0) {
+            var P = i.get(d);
+            g(P) || (P.delete(p), P.size === 0 && i.delete(P));
+          }
+          return !0;
+        }
+      }
+      function at(n) {
+        var i = n.defineMetadata, u = n.hasOwnMetadata, l = n.getOwnMetadata, y = n.getOwnMetadataKeys, R = n.deleteMetadata, S = new J(), M = {
+          isProviderFor: function(c, h) {
+            var d = S.get(c);
+            return !g(d) && d.has(h) ? !0 : y(c, h).length ? (g(d) && (d = new Z(), S.set(c, d)), d.add(h), !0) : !1;
+          },
+          OrdinaryDefineOwnMetadata: i,
+          OrdinaryHasOwnMetadata: u,
+          OrdinaryGetOwnMetadata: l,
+          OrdinaryOwnMetadataKeys: y,
+          OrdinaryDeleteMetadata: R
+        };
+        return M;
+      }
+      function F(n, i, u) {
+        var l = V.getProvider(n, i);
+        if (!g(l))
+          return l;
+        if (u) {
+          if (V.setProvider(n, i, ce))
+            return ce;
+          throw new Error("Illegal state.");
+        }
+      }
+      function ot() {
+        var n = {}, i = [], u = (
+          /** @class */
+          (function() {
+            function M(c, h, d) {
+              this._index = 0, this._keys = c, this._values = h, this._selector = d;
+            }
+            return M.prototype["@@iterator"] = function() {
+              return this;
+            }, M.prototype[m] = function() {
+              return this;
+            }, M.prototype.next = function() {
+              var c = this._index;
+              if (c >= 0 && c < this._keys.length) {
+                var h = this._selector(this._keys[c], this._values[c]);
+                return c + 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 };
+            }, M.prototype.throw = function(c) {
+              throw this._index >= 0 && (this._index = -1, this._keys = i, this._values = i), c;
+            }, M.prototype.return = function(c) {
+              return this._index >= 0 && (this._index = -1, this._keys = i, this._values = i), { value: c, done: !0 };
+            }, M;
+          })()
+        ), l = (
+          /** @class */
+          (function() {
+            function M() {
+              this._keys = [], this._values = [], this._cacheKey = n, this._cacheIndex = -2;
+            }
+            return Object.defineProperty(M.prototype, "size", {
+              get: function() {
+                return this._keys.length;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), M.prototype.has = function(c) {
+              return this._find(
+                c,
+                /*insert*/
+                !1
+              ) >= 0;
+            }, M.prototype.get = function(c) {
+              var h = this._find(
+                c,
+                /*insert*/
+                !1
+              );
+              return h >= 0 ? this._values[h] : void 0;
+            }, M.prototype.set = function(c, h) {
+              var d = this._find(
+                c,
+                /*insert*/
+                !0
+              );
+              return this._values[d] = h, this;
+            }, M.prototype.delete = function(c) {
+              var h = this._find(
+                c,
+                /*insert*/
+                !1
+              );
+              if (h >= 0) {
+                for (var d = this._keys.length, p = h + 1; p < d; p++)
+                  this._keys[p - 1] = this._keys[p], this._values[p - 1] = this._values[p];
+                return this._keys.length--, this._values.length--, Q(c, this._cacheKey) && (this._cacheKey = n, this._cacheIndex = -2), !0;
+              }
+              return !1;
+            }, M.prototype.clear = function() {
+              this._keys.length = 0, this._values.length = 0, this._cacheKey = n, this._cacheIndex = -2;
+            }, M.prototype.keys = function() {
+              return new u(this._keys, this._values, y);
+            }, M.prototype.values = function() {
+              return new u(this._keys, this._values, R);
+            }, M.prototype.entries = function() {
+              return new u(this._keys, this._values, S);
+            }, M.prototype["@@iterator"] = function() {
+              return this.entries();
+            }, M.prototype[m] = function() {
+              return this.entries();
+            }, M.prototype._find = function(c, h) {
+              if (!Q(this._cacheKey, c)) {
+                this._cacheIndex = -1;
+                for (var d = 0; d < this._keys.length; d++)
+                  if (Q(this._keys[d], c)) {
+                    this._cacheIndex = d;
+                    break;
+                  }
+              }
+              return this._cacheIndex < 0 && h && (this._cacheIndex = this._keys.length, this._keys.push(c), this._values.push(void 0)), this._cacheIndex;
+            }, M;
+          })()
+        );
+        return l;
+        function y(M, c) {
+          return M;
+        }
+        function R(M, c) {
+          return c;
+        }
+        function S(M, c) {
+          return [M, c];
+        }
+      }
+      function ut() {
+        var n = (
+          /** @class */
+          (function() {
+            function i() {
+              this._map = new H();
+            }
+            return Object.defineProperty(i.prototype, "size", {
+              get: function() {
+                return this._map.size;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), i.prototype.has = function(u) {
+              return this._map.has(u);
+            }, i.prototype.add = function(u) {
+              return this._map.set(u, u), this;
+            }, i.prototype.delete = function(u) {
+              return this._map.delete(u);
+            }, 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[m] = function() {
+              return this.keys();
+            }, i;
+          })()
+        );
+        return n;
+      }
+      function lt() {
+        var n = 16, i = C.create(), u = l();
+        return (
+          /** @class */
+          (function() {
+            function c() {
+              this._key = l();
+            }
+            return c.prototype.has = function(h) {
+              var d = y(
+                h,
+                /*create*/
+                !1
+              );
+              return d !== void 0 ? C.has(d, this._key) : !1;
+            }, c.prototype.get = function(h) {
+              var d = y(
+                h,
+                /*create*/
+                !1
+              );
+              return d !== void 0 ? C.get(d, this._key) : void 0;
+            }, c.prototype.set = function(h, d) {
+              var p = y(
+                h,
+                /*create*/
+                !0
+              );
+              return p[this._key] = d, this;
+            }, c.prototype.delete = function(h) {
+              var d = y(
+                h,
+                /*create*/
+                !1
+              );
+              return d !== void 0 ? delete d[this._key] : !1;
+            }, c.prototype.clear = function() {
+              this._key = l();
+            }, c;
+          })()
+        );
+        function l() {
+          var c;
+          do
+            c = "@@WeakMap@@" + M();
+          while (C.has(i, c));
+          return i[c] = !0, c;
+        }
+        function y(c, h) {
+          if (!a.call(c, u)) {
+            if (!h)
+              return;
+            Object.defineProperty(c, u, { value: C.create() });
+          }
+          return c[u];
+        }
+        function R(c, h) {
+          for (var d = 0; d < h; ++d)
+            c[d] = Math.random() * 255 | 0;
+          return c;
+        }
+        function S(c) {
+          if (typeof Uint8Array == "function") {
+            var h = new Uint8Array(c);
+            return typeof crypto < "u" ? crypto.getRandomValues(h) : typeof msCrypto < "u" ? msCrypto.getRandomValues(h) : R(h, c), h;
+          }
+          return R(new Array(c), c);
+        }
+        function M() {
+          var c = S(n);
+          c[6] = c[6] & 79 | 64, c[8] = c[8] & 191 | 128;
+          for (var h = "", d = 0; d < n; ++d) {
+            var p = c[d];
+            (d === 4 || d === 6 || d === 8) && (h += "-"), p < 16 && (h += "0"), h += p.toString(16).toLowerCase();
+          }
+          return h;
+        }
+      }
+      function K(n) {
+        return n.__ = void 0, delete n.__, n;
+      }
+    });
+  })(t || (t = {})), Ce;
+}
+Ot();
+function Et(t) {
   const e = (
     /* glsl */
     `
@@ -17,7 +835,7 @@ function M(s) {
       gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
     }
   `
-  ), t = (
+  ), r = (
     /* glsl */
     `
     precision highp float;
@@ -35,16 +853,16 @@ function M(s) {
     }
   `
   );
-  return new v(s, {
+  return new ht(t, {
     vertex: e,
-    fragment: t,
+    fragment: r,
     cullFace: !1,
     uniforms: {
       uHit: { value: 0 }
     }
   });
 }
-class u {
+class ke {
   /** Экземпляр рендерера OGL */
   gl;
   /** Корневой объект сцены */
@@ -62,7 +880,7 @@ 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 = [];
+    this.canvas = e, this.gl = new dt({ 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 pt(), this.camera = new vt(this.gl.gl, { fov: 45 }), this.camera.position.set(1, 1, 7), this.camera.lookAt([0, 0, 0]), this.program = Et(this.gl.gl), this.meshes = [];
   }
   /**
    * Обновляет размер рендерера и камеры при изменении размеров canvas.
@@ -89,37 +907,603 @@ class u {
   }
   /**
    * Публичный метод для добавления фигуры.
-   * @param figure Данные фигуры: position, normal, uv
+   * @param figure - Данные фигуры: position, normal, uv
    */
   addFigure(e) {
-    const t = new y(this.gl.gl, {
+    const r = new yt(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,
+    }), s = new gt(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;
   }
   /** Деструктор */
   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 St extends De {
   /** Используется ли 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);
+  constructor(e, r = {}) {
+    super(e, 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);
   }
 }
-class F extends u {
+var ee;
+(function(t) {
+  t[t.Transient = 0] = "Transient", t[t.Singleton = 1] = "Singleton", t[t.ResolutionScoped = 2] = "ResolutionScoped", t[t.ContainerScoped = 3] = "ContainerScoped";
+})(ee || (ee = {}));
+const I = ee;
+/*! *****************************************************************************
+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 te = function(t, e) {
+  return te = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, s) {
+    r.__proto__ = s;
+  } || function(r, s) {
+    for (var a in s) s.hasOwnProperty(a) && (r[a] = s[a]);
+  }, te(t, e);
+};
+function ue(t, e) {
+  te(t, e);
+  function r() {
+    this.constructor = t;
+  }
+  t.prototype = e === null ? Object.create(e) : (r.prototype = e.prototype, new r());
+}
+function It(t, e, r, s) {
+  function a(o) {
+    return o instanceof r ? o : new r(function(f) {
+      f(o);
+    });
+  }
+  return new (r || (r = Promise))(function(o, f) {
+    function m(b) {
+      try {
+        v(s.next(b));
+      } catch (C) {
+        f(C);
+      }
+    }
+    function w(b) {
+      try {
+        v(s.throw(b));
+      } catch (C) {
+        f(C);
+      }
+    }
+    function v(b) {
+      b.done ? o(b.value) : a(b.value).then(m, w);
+    }
+    v((s = s.apply(t, [])).next());
+  });
+}
+function Ct(t, e) {
+  var r = { label: 0, sent: function() {
+    if (o[0] & 1) throw o[1];
+    return o[1];
+  }, trys: [], ops: [] }, s, a, o, f;
+  return f = { next: m(0), throw: m(1), return: m(2) }, typeof Symbol == "function" && (f[Symbol.iterator] = function() {
+    return this;
+  }), f;
+  function m(v) {
+    return function(b) {
+      return w([v, b]);
+    };
+  }
+  function w(v) {
+    if (s) throw new TypeError("Generator is already executing.");
+    for (; r; ) try {
+      if (s = 1, a && (o = v[0] & 2 ? a.return : v[0] ? a.throw || ((o = a.return) && o.call(a), 0) : a.next) && !(o = o.call(a, v[1])).done) return o;
+      switch (a = 0, o && (v = [v[0] & 2, o.value]), v[0]) {
+        case 0:
+        case 1:
+          o = v;
+          break;
+        case 4:
+          return r.label++, { value: v[1], done: !1 };
+        case 5:
+          r.label++, a = v[1], v = [0];
+          continue;
+        case 7:
+          v = r.ops.pop(), r.trys.pop();
+          continue;
+        default:
+          if (o = r.trys, !(o = o.length > 0 && o[o.length - 1]) && (v[0] === 6 || v[0] === 2)) {
+            r = 0;
+            continue;
+          }
+          if (v[0] === 3 && (!o || v[1] > o[0] && v[1] < o[3])) {
+            r.label = v[1];
+            break;
+          }
+          if (v[0] === 6 && r.label < o[1]) {
+            r.label = o[1], o = v;
+            break;
+          }
+          if (o && r.label < o[2]) {
+            r.label = o[2], r.ops.push(v);
+            break;
+          }
+          o[2] && r.ops.pop(), r.trys.pop();
+          continue;
+      }
+      v = e.call(t, r);
+    } catch (b) {
+      v = [6, b], a = 0;
+    } finally {
+      s = o = 0;
+    }
+    if (v[0] & 5) throw v[1];
+    return { value: v[0] ? v[1] : void 0, done: !0 };
+  }
+}
+function z(t) {
+  var e = typeof Symbol == "function" && Symbol.iterator, r = e && t[e], s = 0;
+  if (r) return r.call(t);
+  if (t && typeof t.length == "number") return {
+    next: function() {
+      return t && s >= t.length && (t = void 0), { value: t && t[s++], done: !t };
+    }
+  };
+  throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function B(t, e) {
+  var r = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!r) return t;
+  var s = r.call(t), a, o = [], f;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(a = s.next()).done; ) o.push(a.value);
+  } catch (m) {
+    f = { error: m };
+  } finally {
+    try {
+      a && !a.done && (r = s.return) && r.call(s);
+    } finally {
+      if (f) throw f.error;
+    }
+  }
+  return o;
+}
+function A() {
+  for (var t = [], e = 0; e < arguments.length; e++)
+    t = t.concat(B(arguments[e]));
+  return t;
+}
+var re = "injectionTokens";
+function Tt(t) {
+  var e = Reflect.getMetadata("design:paramtypes", t) || [], r = Reflect.getOwnMetadata(re, t) || {};
+  return Object.keys(r).forEach(function(s) {
+    e[+s] = r[s];
+  }), e;
+}
+function je(t, e) {
+  return function(r, s, a) {
+    var o = Reflect.getOwnMetadata(re, r) || {};
+    o[a] = t, Reflect.defineMetadata(re, o, r);
+  };
+}
+function Ne(t) {
+  return !!t.useClass;
+}
+function ne(t) {
+  return !!t.useFactory;
+}
+var He = (function() {
+  function t(e) {
+    this.wrap = e, this.reflectMethods = [
+      "get",
+      "getPrototypeOf",
+      "setPrototypeOf",
+      "getOwnPropertyDescriptor",
+      "defineProperty",
+      "has",
+      "set",
+      "deleteProperty",
+      "apply",
+      "construct",
+      "ownKeys"
+    ];
+  }
+  return t.prototype.createProxy = function(e) {
+    var r = this, s = {}, a = !1, o, f = function() {
+      return a || (o = e(r.wrap()), a = !0), o;
+    };
+    return new Proxy(s, this.createHandler(f));
+  }, t.prototype.createHandler = function(e) {
+    var r = {}, s = function(a) {
+      r[a] = function() {
+        for (var o = [], f = 0; f < arguments.length; f++)
+          o[f] = arguments[f];
+        o[0] = e();
+        var m = Reflect[a];
+        return m.apply(void 0, A(o));
+      };
+    };
+    return this.reflectMethods.forEach(s), r;
+  }, t;
+})();
+function j(t) {
+  return typeof t == "string" || typeof t == "symbol";
+}
+function xt(t) {
+  return typeof t == "object" && "token" in t && "multiple" in t;
+}
+function xe(t) {
+  return typeof t == "object" && "token" in t && "transform" in t;
+}
+function At(t) {
+  return typeof t == "function" || t instanceof He;
+}
+function $(t) {
+  return !!t.useToken;
+}
+function q(t) {
+  return t.useValue != null;
+}
+function Dt(t) {
+  return Ne(t) || q(t) || $(t) || ne(t);
+}
+var le = (function() {
+  function t() {
+    this._registryMap = /* @__PURE__ */ new Map();
+  }
+  return t.prototype.entries = function() {
+    return this._registryMap.entries();
+  }, t.prototype.getAll = function(e) {
+    return this.ensure(e), this._registryMap.get(e);
+  }, t.prototype.get = function(e) {
+    this.ensure(e);
+    var r = this._registryMap.get(e);
+    return r[r.length - 1] || null;
+  }, t.prototype.set = function(e, r) {
+    this.ensure(e), this._registryMap.get(e).push(r);
+  }, t.prototype.setAll = function(e, r) {
+    this._registryMap.set(e, r);
+  }, t.prototype.has = function(e) {
+    return this.ensure(e), this._registryMap.get(e).length > 0;
+  }, t.prototype.clear = function() {
+    this._registryMap.clear();
+  }, t.prototype.ensure = function(e) {
+    this._registryMap.has(e) || this._registryMap.set(e, []);
+  }, t;
+})(), kt = (function(t) {
+  ue(e, t);
+  function e() {
+    return t !== null && t.apply(this, arguments) || this;
+  }
+  return e;
+})(le), U = /* @__PURE__ */ (function() {
+  function t() {
+    this.scopedResolutions = /* @__PURE__ */ new Map();
+  }
+  return t;
+})();
+function jt(t, e) {
+  if (t === null)
+    return "at position #" + e;
+  var r = t.split(",")[e].trim();
+  return '"' + r + '" at position #' + e;
+}
+function Nt(t, e, r) {
+  return r === void 0 && (r = "    "), A([t], e.message.split(`
+`).map(function(s) {
+    return r + s;
+  })).join(`
+`);
+}
+function Ht(t, e, r) {
+  var s = B(t.toString().match(/constructor\(([\w, ]+)\)/) || [], 2), a = s[1], o = a === void 0 ? null : a, f = jt(o, e);
+  return Nt("Cannot inject the dependency " + f + ' of "' + t.name + '" constructor. Reason:', r);
+}
+function Ft(t) {
+  if (typeof t.dispose != "function")
+    return !1;
+  var e = t.dispose;
+  return !(e.length > 0);
+}
+var Gt = (function(t) {
+  ue(e, t);
+  function e() {
+    return t !== null && t.apply(this, arguments) || this;
+  }
+  return e;
+})(le), Lt = (function(t) {
+  ue(e, t);
+  function e() {
+    return t !== null && t.apply(this, arguments) || this;
+  }
+  return e;
+})(le), Vt = /* @__PURE__ */ (function() {
+  function t() {
+    this.preResolution = new Gt(), this.postResolution = new Lt();
+  }
+  return t;
+})(), Fe = /* @__PURE__ */ new Map(), Wt = (function() {
+  function t(e) {
+    this.parent = e, this._registry = new kt(), this.interceptors = new Vt(), this.disposed = !1, this.disposables = /* @__PURE__ */ new Set();
+  }
+  return t.prototype.register = function(e, r, s) {
+    s === void 0 && (s = { lifecycle: I.Transient }), this.ensureNotDisposed();
+    var a;
+    if (Dt(r) ? a = r : a = { useClass: r }, $(a))
+      for (var o = [e], f = a; f != null; ) {
+        var m = f.useToken;
+        if (o.includes(m))
+          throw new Error("Token registration cycle detected! " + A(o, [m]).join(" -> "));
+        o.push(m);
+        var w = this._registry.get(m);
+        w && $(w.provider) ? f = w.provider : f = null;
+      }
+    if ((s.lifecycle === I.Singleton || s.lifecycle == I.ContainerScoped || s.lifecycle == I.ResolutionScoped) && (q(a) || ne(a)))
+      throw new Error('Cannot use lifecycle "' + I[s.lifecycle] + '" with ValueProviders or FactoryProviders');
+    return this._registry.set(e, { provider: a, options: s }), this;
+  }, t.prototype.registerType = function(e, r) {
+    return this.ensureNotDisposed(), j(r) ? this.register(e, {
+      useToken: r
+    }) : this.register(e, {
+      useClass: r
+    });
+  }, t.prototype.registerInstance = function(e, r) {
+    return this.ensureNotDisposed(), this.register(e, {
+      useValue: r
+    });
+  }, t.prototype.registerSingleton = function(e, r) {
+    if (this.ensureNotDisposed(), j(e)) {
+      if (j(r))
+        return this.register(e, {
+          useToken: r
+        }, { lifecycle: I.Singleton });
+      if (r)
+        return this.register(e, {
+          useClass: r
+        }, { lifecycle: I.Singleton });
+      throw new Error('Cannot register a type name as a singleton without a "to" token');
+    }
+    var s = e;
+    return r && !j(r) && (s = r), this.register(e, {
+      useClass: s
+    }, { lifecycle: I.Singleton });
+  }, t.prototype.resolve = function(e, r, s) {
+    r === void 0 && (r = new U()), s === void 0 && (s = !1), this.ensureNotDisposed();
+    var a = this.getRegistration(e);
+    if (!a && j(e)) {
+      if (s)
+        return;
+      throw new Error('Attempted to resolve unregistered dependency token: "' + e.toString() + '"');
+    }
+    if (this.executePreResolutionInterceptor(e, "Single"), a) {
+      var o = this.resolveRegistration(a, r);
+      return this.executePostResolutionInterceptor(e, o, "Single"), o;
+    }
+    if (At(e)) {
+      var o = this.construct(e, r);
+      return this.executePostResolutionInterceptor(e, o, "Single"), o;
+    }
+    throw new Error("Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.");
+  }, t.prototype.executePreResolutionInterceptor = function(e, r) {
+    var s, a;
+    if (this.interceptors.preResolution.has(e)) {
+      var o = [];
+      try {
+        for (var f = z(this.interceptors.preResolution.getAll(e)), m = f.next(); !m.done; m = f.next()) {
+          var w = m.value;
+          w.options.frequency != "Once" && o.push(w), w.callback(e, r);
+        }
+      } catch (v) {
+        s = { error: v };
+      } finally {
+        try {
+          m && !m.done && (a = f.return) && a.call(f);
+        } finally {
+          if (s) throw s.error;
+        }
+      }
+      this.interceptors.preResolution.setAll(e, o);
+    }
+  }, t.prototype.executePostResolutionInterceptor = function(e, r, s) {
+    var a, o;
+    if (this.interceptors.postResolution.has(e)) {
+      var f = [];
+      try {
+        for (var m = z(this.interceptors.postResolution.getAll(e)), w = m.next(); !w.done; w = m.next()) {
+          var v = w.value;
+          v.options.frequency != "Once" && f.push(v), v.callback(e, r, s);
+        }
+      } catch (b) {
+        a = { error: b };
+      } finally {
+        try {
+          w && !w.done && (o = m.return) && o.call(m);
+        } finally {
+          if (a) throw a.error;
+        }
+      }
+      this.interceptors.postResolution.setAll(e, f);
+    }
+  }, t.prototype.resolveRegistration = function(e, r) {
+    if (this.ensureNotDisposed(), e.options.lifecycle === I.ResolutionScoped && r.scopedResolutions.has(e))
+      return r.scopedResolutions.get(e);
+    var s = e.options.lifecycle === I.Singleton, a = e.options.lifecycle === I.ContainerScoped, o = s || a, f;
+    return q(e.provider) ? f = e.provider.useValue : $(e.provider) ? f = o ? e.instance || (e.instance = this.resolve(e.provider.useToken, r)) : this.resolve(e.provider.useToken, r) : Ne(e.provider) ? f = o ? e.instance || (e.instance = this.construct(e.provider.useClass, r)) : this.construct(e.provider.useClass, r) : ne(e.provider) ? f = e.provider.useFactory(this) : f = this.construct(e.provider, r), e.options.lifecycle === I.ResolutionScoped && r.scopedResolutions.set(e, f), f;
+  }, t.prototype.resolveAll = function(e, r, s) {
+    var a = this;
+    r === void 0 && (r = new U()), s === void 0 && (s = !1), this.ensureNotDisposed();
+    var o = this.getAllRegistrations(e);
+    if (!o && j(e)) {
+      if (s)
+        return [];
+      throw new Error('Attempted to resolve unregistered dependency token: "' + e.toString() + '"');
+    }
+    if (this.executePreResolutionInterceptor(e, "All"), o) {
+      var f = o.map(function(w) {
+        return a.resolveRegistration(w, r);
+      });
+      return this.executePostResolutionInterceptor(e, f, "All"), f;
+    }
+    var m = [this.construct(e, r)];
+    return this.executePostResolutionInterceptor(e, m, "All"), m;
+  }, t.prototype.isRegistered = function(e, r) {
+    return r === void 0 && (r = !1), this.ensureNotDisposed(), this._registry.has(e) || r && (this.parent || !1) && this.parent.isRegistered(e, !0);
+  }, t.prototype.reset = function() {
+    this.ensureNotDisposed(), this._registry.clear(), this.interceptors.preResolution.clear(), this.interceptors.postResolution.clear();
+  }, t.prototype.clearInstances = function() {
+    var e, r;
+    this.ensureNotDisposed();
+    try {
+      for (var s = z(this._registry.entries()), a = s.next(); !a.done; a = s.next()) {
+        var o = B(a.value, 2), f = o[0], m = o[1];
+        this._registry.setAll(f, m.filter(function(w) {
+          return !q(w.provider);
+        }).map(function(w) {
+          return w.instance = void 0, w;
+        }));
+      }
+    } catch (w) {
+      e = { error: w };
+    } finally {
+      try {
+        a && !a.done && (r = s.return) && r.call(s);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+  }, t.prototype.createChildContainer = function() {
+    var e, r;
+    this.ensureNotDisposed();
+    var s = new t(this);
+    try {
+      for (var a = z(this._registry.entries()), o = a.next(); !o.done; o = a.next()) {
+        var f = B(o.value, 2), m = f[0], w = f[1];
+        w.some(function(v) {
+          var b = v.options;
+          return b.lifecycle === I.ContainerScoped;
+        }) && s._registry.setAll(m, w.map(function(v) {
+          return v.options.lifecycle === I.ContainerScoped ? {
+            provider: v.provider,
+            options: v.options
+          } : v;
+        }));
+      }
+    } catch (v) {
+      e = { error: v };
+    } finally {
+      try {
+        o && !o.done && (r = a.return) && r.call(a);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+    return s;
+  }, t.prototype.beforeResolution = function(e, r, s) {
+    s === void 0 && (s = { frequency: "Always" }), this.interceptors.preResolution.set(e, {
+      callback: r,
+      options: s
+    });
+  }, t.prototype.afterResolution = function(e, r, s) {
+    s === void 0 && (s = { frequency: "Always" }), this.interceptors.postResolution.set(e, {
+      callback: r,
+      options: s
+    });
+  }, t.prototype.dispose = function() {
+    return It(this, void 0, void 0, function() {
+      var e;
+      return Ct(this, function(r) {
+        switch (r.label) {
+          case 0:
+            return this.disposed = !0, e = [], this.disposables.forEach(function(s) {
+              var a = s.dispose();
+              a && e.push(a);
+            }), [4, Promise.all(e)];
+          case 1:
+            return r.sent(), [2];
+        }
+      });
+    });
+  }, t.prototype.getRegistration = function(e) {
+    return this.isRegistered(e) ? this._registry.get(e) : this.parent ? this.parent.getRegistration(e) : null;
+  }, t.prototype.getAllRegistrations = function(e) {
+    return this.isRegistered(e) ? this._registry.getAll(e) : this.parent ? this.parent.getAllRegistrations(e) : null;
+  }, t.prototype.construct = function(e, r) {
+    var s = this;
+    if (e instanceof He)
+      return e.createProxy(function(o) {
+        return s.resolve(o, r);
+      });
+    var a = (function() {
+      var o = Fe.get(e);
+      if (!o || o.length === 0) {
+        if (e.length === 0)
+          return new e();
+        throw new Error('TypeInfo not known for "' + e.name + '"');
+      }
+      var f = o.map(s.resolveParams(r, e));
+      return new (e.bind.apply(e, A([void 0], f)))();
+    })();
+    return Ft(a) && this.disposables.add(a), a;
+  }, t.prototype.resolveParams = function(e, r) {
+    var s = this;
+    return function(a, o) {
+      var f, m, w;
+      try {
+        return xt(a) ? xe(a) ? a.multiple ? (f = s.resolve(a.transform)).transform.apply(f, A([s.resolveAll(a.token, new U(), a.isOptional)], a.transformArgs)) : (m = s.resolve(a.transform)).transform.apply(m, A([s.resolve(a.token, e, a.isOptional)], a.transformArgs)) : a.multiple ? s.resolveAll(a.token, new U(), a.isOptional) : s.resolve(a.token, e, a.isOptional) : xe(a) ? (w = s.resolve(a.transform, e)).transform.apply(w, A([s.resolve(a.token, e)], a.transformArgs)) : s.resolve(a, e);
+      } catch (v) {
+        throw new Error(Ht(r, o, v));
+      }
+    };
+  }, t.prototype.ensureNotDisposed = function() {
+    if (this.disposed)
+      throw new Error("This container has been disposed, you cannot interact with a disposed container");
+  }, t;
+})(), zt = new Wt();
+function fe(t, e) {
+  var r = {
+    token: t,
+    multiple: !1,
+    isOptional: e
+  };
+  return je(r);
+}
+function L(t) {
+  return function(e) {
+    Fe.set(e, Tt(e));
+  };
+}
+function Ut(t, e) {
+  var r = {
+    token: t,
+    multiple: !0,
+    isOptional: e
+  };
+  return je(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 $t = Object.getOwnPropertyDescriptor, qt = (t, e, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? $t(e, r) : e, o = t.length - 1, f; o >= 0; o--)
+    (f = t[o]) && (a = f(a) || a);
+  return a;
+};
+let Ae = class extends ke {
   /** Orbit-контроллер для управления камерой */
   orbit;
   /** Raycast для подсветки моделей при наведении */
@@ -133,10 +1517,46 @@ class F extends u {
    * Создает сетку, оси координат и 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(t) {
+    super(t);
+    const e = new mt(this.gl.gl, { size: 10, divisions: 10 });
+    e.position.y = -1e-3, e.setParent(this.scene), new wt(this.gl.gl, { size: 6, symmetric: !0 }).setParent(this.scene), this.orbit = new St(this.camera, { element: this.canvas }), this.raycast = new Mt(), this.mouse = new _t(), this.isEventListenersAdded = !1;
+  }
+  /**
+   * Добавляет фигуру в сцену и сохраняет его во внутреннем массиве.
+   *
+   * @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;
   }
   /**
    * Обновление состояния рендерера.
@@ -147,23 +1567,23 @@ class F extends u {
   /**
    * Метод для добавления фигуры.
    * Настройка 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";
+  addFigure(t) {
+    const e = super.addFigure(t);
+    if (e.geometry) {
+      const r = e.geometry.constructor.name;
+      e.geometry.raycast = r.includes("Sphere") ? "sphere" : "box";
     }
-    return t.isHit = !1, t.onBeforeRender(({ mesh: i }) => {
-      this.updateHitUniform(i);
-    }), this.isEventListenersAdded || this.initMouseListeners(), t;
+    return e.isHit = !1, e.onBeforeRender(({ mesh: r }) => {
+      this.updateHitUniform(r);
+    }), this.isEventListenersAdded || this.initMouseListeners(), e;
   }
   /**
    * Обновление uniform uHit для конкретной 3D-модели
    */
-  updateHitUniform(e) {
-    this.program.uniforms.uHit.value = e.isHit ? 1 : 0;
+  updateHitUniform(t) {
+    this.program.uniforms.uHit.value = t.isHit ? 1 : 0;
   }
   /**
    * Инициализация обработчиков мыши для raycast
@@ -174,16 +1594,19 @@ class F extends u {
   /**
    * Обработчик движения мыши
    */
-  handleMouseMove = (e) => {
+  handleMouseMove = (t) => {
     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);
+    this.mouse.set(2 * (t.x / this.gl.width) - 1, 2 * (1 - t.y / this.gl.height) - 1), this.raycast.castMouse(this.camera, this.mouse), this.meshes.forEach((r) => r.isHit = !1), this.raycast.intersectBounds(this.meshes).forEach((r) => r.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();
   }
-}
-class z extends u {
+};
+Ae = qt([
+  L()
+], Ae);
+class ur extends ke {
   /** Orbit-контроллер для управления камерой */
   orbit;
   /**
@@ -191,9 +1614,9 @@ class z extends u {
    * @param canvas - HTMLCanvasElement для рендеринга
    */
   constructor(e) {
-    super(e), this.orbit = new c(this.camera, {
+    super(e), this.orbit = new De(this.camera, {
       element: this.canvas,
-      target: new E(0, 0, 0),
+      target: new bt(0, 0, 0),
       minPolarAngle: Math.PI / 2,
       maxPolarAngle: Math.PI / 2,
       enableRotate: !0,
@@ -208,7 +1631,7 @@ class z extends u {
     this.orbit?.update();
   }
 }
-class A {
+class Bt {
   /** Тип фигуры */
   type;
   /** Позиции вершин */
@@ -227,8 +1650,8 @@ class A {
     this.type = e.type, this.position = e.position, this.normal = e.normal ?? [], this.uv = e.uv ?? [], this.material = e.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 Ge = /* @__PURE__ */ ((t) => (t[t.Cube = 0] = "Cube", t[t.Sphere = 1] = "Sphere", t[t.Plane = 2] = "Plane", t[t.Cylinder = 3] = "Cylinder", t[t.Custom = 4] = "Custom", t))(Ge || {}), G = /* @__PURE__ */ ((t) => (t.Plane = "plane", t.Wireframe = "wireframe", t.Texture = "texture", t))(G || {});
+class lr {
   /** Позиции вершин */
   positions = [];
   /** Нормали вершин */
@@ -241,64 +1664,206 @@ class C {
   tmpUVs = [];
   /**
    * Загружает OBJ-модель в Figure
-   * @param objContent Строка содержимого .obj файла
+   * @param objContent - Строка содержимого .obj файла
    */
   load(e) {
-    const t = e.split(`
+    const r = e.split(`
 `);
-    for (const a of t) {
+    for (const a of r) {
       if (!a.trim() || a.startsWith("#")) continue;
-      const r = a.trim().split(/\s+/);
-      switch (r[0]) {
+      const o = a.trim().split(/\s+/);
+      switch (o[0]) {
         case "v":
-          this.tmpPositions.push(r.slice(1).map(Number));
+          this.tmpPositions.push(o.slice(1).map(Number));
           break;
         case "vn":
-          this.tmpNormals.push(r.slice(1).map(Number));
+          this.tmpNormals.push(o.slice(1).map(Number));
           break;
         case "vt":
-          this.tmpUVs.push(r.slice(1).map(Number));
+          this.tmpUVs.push(o.slice(1).map(Number));
           break;
         case "f":
-          this.processFaceLine(r);
+          this.processFaceLine(o);
           break;
       }
     }
-    const i = {
-      type: d.Custom,
+    const s = {
+      type: Ge.Custom,
       position: this.positions,
       ...this.normals.length > 0 && { normal: this.normals },
       ...this.uvs.length > 0 && { uv: this.uvs }
     };
-    return new A(i);
+    return new Bt(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);
-      }
+    for (let r = 1; r < e.length; r++) {
+      const s = e[r];
+      if (!s) continue;
+      const [a, o, f] = s.split("/"), m = a ? parseInt(a, 10) : void 0, w = o ? parseInt(o, 10) : void 0, v = f ? parseInt(f, 10) : void 0;
       if (m !== void 0) {
-        const n = this.tmpNormals[m - 1];
-        n && this.normals.push(...n);
+        const b = this.tmpPositions[m - 1];
+        b && this.positions.push(...b);
+      }
+      if (w !== void 0) {
+        const b = this.tmpUVs[w - 1];
+        b && this.uvs.push(...b);
+      }
+      if (v !== void 0) {
+        const b = this.tmpNormals[v - 1];
+        b && this.normals.push(...b);
       }
     }
   }
 }
+var Zt = Object.getOwnPropertyDescriptor, Jt = (t, e, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? Zt(e, r) : e, o = t.length - 1, f; o >= 0; o--)
+    (f = t[o]) && (a = f(a) || a);
+  return a;
+}, Yt = (t, e) => (r, s) => e(r, s, t);
+let ie = class {
+  /** Текущий режим отображения */
+  currentMode = G.Plane;
+  /** Хендлеры, которые управляют отображением */
+  handlers;
+  constructor(t) {
+    this.handlers = new Map(t.map((e) => [e.mode, e]));
+  }
+  /** Установка режима отображения */
+  manage(t) {
+    t !== this.currentMode && (this.handlers.get(this.currentMode)?.rollback(), t !== G.Plane && this.handlers.get(t)?.handle(), this.currentMode = t);
+  }
+  /** Освобождение ресурсов */
+  destroy() {
+    this.handlers && this.handlers.clear(), this.currentMode = G.Plane;
+  }
+};
+ie = Jt([
+  L(),
+  Yt(0, Ut("IDisplayHandler"))
+], ie);
+var Qt = Object.getOwnPropertyDescriptor, Xt = (t, e, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? Qt(e, r) : e, o = t.length - 1, f; o >= 0; o--)
+    (f = t[o]) && (a = f(a) || a);
+  return a;
+}, Kt = (t, e) => (r, s) => e(r, s, t);
+let se = class {
+  constructor(t) {
+    this.api = t, this.wireMeshes = [], this.context = this.api.getContext(), this.wireMeshProgram = new Pt(this.context);
+  }
+  /** Режим отображения */
+  mode = G.Wireframe;
+  /** Wireframe-модели для добавленных на сцену объектов */
+  wireMeshes;
+  /** Настройки рендеринга для режима wireframe */
+  wireMeshProgram;
+  /** WebGl контекст */
+  context;
+  /**
+   * Применяет wireframe-режим к сцене.
+   */
+  handle() {
+    const t = this.api.getMeshes();
+    this.createWireMeshes(t), this.api.removeMeshes(t), this.api.addMeshes(this.wireMeshes);
+  }
+  /**
+   * Отменяет wireframe-режим у сцены.
+   */
+  rollback() {
+    const t = this.api.getMeshes();
+    this.api.removeMeshes(this.wireMeshes), this.api.addMeshes(t);
+  }
+  /**
+   * Освобождает ресурсы хендлера, удаляет wireframe-модели со сцены.
+   */
+  destroy() {
+    this.wireMeshes && (this.wireMeshes.length = 0, this.wireMeshes = []);
+  }
+  /**
+   * Создание wireframe-моделей для фигур на сцене.
+   */
+  createWireMeshes(t) {
+    for (const e of t) {
+      const r = new Rt(this.context, {
+        geometry: e.geometry,
+        program: this.wireMeshProgram
+      });
+      this.wireMeshes.push(r);
+    }
+  }
+};
+se = Xt([
+  L(),
+  Kt(0, fe("RendererApi"))
+], se);
+var er = Object.getOwnPropertyDescriptor, tr = (t, e, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? er(e, r) : e, o = t.length - 1, f; o >= 0; o--)
+    (f = t[o]) && (a = f(a) || a);
+  return a;
+}, rr = (t, e) => (r, s) => e(r, s, t);
+let ae = class {
+  constructor(t) {
+    this.renderer = t;
+  }
+  addMesh(t) {
+    this.renderer.addMesh(t);
+  }
+  addMeshes(t) {
+    for (const e of t)
+      this.renderer.addMesh(e);
+  }
+  removeMesh(t) {
+    this.renderer.removeMesh(t);
+  }
+  removeMeshes(t) {
+    for (const e of t)
+      this.renderer.removeMesh(e);
+  }
+  getMeshes() {
+    return this.renderer.getMeshes();
+  }
+  getContext() {
+    return this.renderer.getContext();
+  }
+};
+ae = tr([
+  L(),
+  rr(0, fe("EditorRenderer"))
+], ae);
+var nr = Object.getOwnPropertyDescriptor, ir = (t, e, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? nr(e, r) : e, o = t.length - 1, f; o >= 0; o--)
+    (f = t[o]) && (a = f(a) || a);
+  return a;
+}, sr = (t, e) => (r, s) => e(r, s, t);
+let oe = class {
+  constructor(t) {
+    this.displayManager = t;
+  }
+  setDisplayMode(t) {
+    this.displayManager.manage(t);
+  }
+  destroy() {
+    this.displayManager.destroy();
+  }
+};
+oe = ir([
+  L(),
+  sr(0, fe("IDisplayManager"))
+], oe);
+function ar(t) {
+  const e = zt.createChildContainer();
+  return e.registerInstance("EditorRenderer", t), e.registerSingleton("RendererApi", ae), e.registerSingleton("IDisplayHandler", se), e.registerSingleton("IDisplayManager", ie), e.registerSingleton("EditorHub", oe), e;
+}
+function fr(t) {
+  return ar(t).resolve("EditorHub");
+}
 export {
-  F as EditorRenderer,
-  C as ObjLoader,
-  z as PreviewRenderer,
-  u as Renderer,
-  M as createProgram
+  oe as EditorHub,
+  Ae as EditorRenderer,
+  lr as ObjLoader,
+  ur as PreviewRenderer,
+  ke as Renderer,
+  fr as createAppHub
 };