@planara/core 2.8.0 → 3.1.0

package/dist/index.es.js

@@ -1,1141 +1,1746 @@
 import "reflect-metadata";
-import * as a from "three";
-import { Controls as Ke, Vector3 as I, MOUSE as Y, TOUCH as z, Quaternion as Ee, Spherical as xe, Vector2 as L, Ray as qe, Plane as Qe, MathUtils as Je } from "three";
-import { FigureType as D, SelectMode as y, Figure as et, DisplayMode as $, DEFAULT_TOOL_RULES as Pe, ToolType as F, SceneMode as U } from "@planara/types";
-import { SymmetricAxesHelper as tt, OrbitWithState as st, CameraAxesGizmo as it, ModelingTransformControls as rt } from "@planara/three";
-import { injectable as M, inject as _, injectAll as G, container as ot } from "tsyringe";
-import { EventEmitter as nt } from "events";
-import { makeAutoObservable as at } from "mobx";
-const ht = {
-  [D.Plane]: () => new a.PlaneGeometry(1, 1, 1, 1),
-  [D.Cube]: () => new a.BoxGeometry(1, 1, 1, 1, 1, 1),
-  [D.UVSphere]: () => new a.SphereGeometry(0.5, 32, 16),
-  [D.Icosphere]: () => new a.IcosahedronGeometry(0.5, 0),
-  [D.Cylinder]: () => new a.CylinderGeometry(0.5, 0.5, 1, 32, 1, !1),
-  [D.Cone]: () => new a.ConeGeometry(0.5, 1, 32, 1, !1),
-  [D.Torus]: () => new a.TorusGeometry(0.5, 0.2, 16, 64),
-  [D.Circle]: () => new a.CircleGeometry(0.5, 32),
-  [D.Sphere]: () => new a.SphereGeometry(0.5, 32, 16),
-  [D.Custom]: function() {
-    throw new Error("Custom geometry is not generated here.");
-  }
-}, ze = new a.MeshStandardMaterial({
-  color: 12566463,
-  metalness: 0,
-  roughness: 0.6
-}), lt = 8;
-class Ne {
-  /** Корневой объект сцены */
-  scene;
-  /** Камера для сцены */
-  camera;
-  /** Экземпляр рендерера Three.js */
-  renderer;
-  /** HTML-элемент canvas, на котором рендерится сцена */
-  canvas;
-  /** Массив моделей на сцене */
-  meshes = [];
+import * as l from "three";
+import { Loader as Ut, FileLoader as Nt, Color as St, SRGBColorSpace as wt, Group as Xt, BufferGeometry as it, Float32BufferAttribute as X, LineBasicMaterial as Se, Material as nt, PointsMaterial as ee, MeshPhongMaterial as Yt, LineSegments as ot, Points as we, Mesh as at, Vector3 as W, Vector2 as qt, Matrix3 as Zt, ColorManagement as Kt } from "three";
+import { injectable as w, inject as _, injectAll as B, container as Jt } from "tsyringe";
+import { FigureType as L, Figure as Qt, SelectMode as P, DisplayMode as K, SceneMode as T, ToolType as U, DEFAULT_TOOL_RULES as es, ResponseType as G } from "@planara/types";
+import { OrbitWithState as ts, ModelingTransformControls as ss, CameraAxesGizmo as rs, SymmetricAxesHelper as is } from "@planara/three";
+import { EventEmitter as ns } from "events";
+import { makeAutoObservable as At, observable as os } from "mobx";
+const as = /^[og]\s*(.+)?/, ls = /^mtllib /, cs = /^usemtl /, hs = /^usemap /, lt = /\s+/, ct = new W(), Ae = new W(), ht = new W(), dt = new W(), j = new W(), te = new St();
+function ds() {
+  const e = {
+    objects: [],
+    object: {},
+    vertices: [],
+    normals: [],
+    colors: [],
+    uvs: [],
+    materials: {},
+    materialLibraries: [],
+    startObject: function(t, s) {
+      if (this.object && this.object.fromDeclaration === !1) {
+        this.object.name = t, this.object.fromDeclaration = s !== !1;
+        return;
+      }
+      const r = this.object && typeof this.object.currentMaterial == "function" ? this.object.currentMaterial() : void 0;
+      if (this.object && typeof this.object._finalize == "function" && this.object._finalize(!0), this.object = {
+        name: t || "",
+        fromDeclaration: s !== !1,
+        geometry: {
+          vertices: [],
+          normals: [],
+          colors: [],
+          uvs: [],
+          hasUVIndices: !1
+        },
+        materials: [],
+        smooth: !0,
+        startMaterial: function(i, n) {
+          const o = this._finalize(!1);
+          o && (o.inherited || o.groupCount <= 0) && this.materials.splice(o.index, 1);
+          const c = {
+            index: this.materials.length,
+            name: i || "",
+            mtllib: Array.isArray(n) && n.length > 0 ? n[n.length - 1] : "",
+            smooth: o !== void 0 ? o.smooth : this.smooth,
+            groupStart: o !== void 0 ? o.groupEnd : 0,
+            groupEnd: -1,
+            groupCount: -1,
+            inherited: !1,
+            clone: function(u) {
+              const d = {
+                index: typeof u == "number" ? u : this.index,
+                name: this.name,
+                mtllib: this.mtllib,
+                smooth: this.smooth,
+                groupStart: 0,
+                groupEnd: -1,
+                groupCount: -1,
+                inherited: !1
+              };
+              return d.clone = this.clone.bind(d), d;
+            }
+          };
+          return this.materials.push(c), c;
+        },
+        currentMaterial: function() {
+          if (this.materials.length > 0)
+            return this.materials[this.materials.length - 1];
+        },
+        _finalize: function(i) {
+          const n = this.currentMaterial();
+          if (n && n.groupEnd === -1 && (n.groupEnd = this.geometry.vertices.length / 3, n.groupCount = n.groupEnd - n.groupStart, n.inherited = !1), i && this.materials.length > 1)
+            for (let o = this.materials.length - 1; o >= 0; o--)
+              this.materials[o].groupCount <= 0 && this.materials.splice(o, 1);
+          return i && this.materials.length === 0 && this.materials.push({
+            name: "",
+            smooth: this.smooth
+          }), n;
+        }
+      }, r && r.name && typeof r.clone == "function") {
+        const i = r.clone(0);
+        i.inherited = !0, this.object.materials.push(i);
+      }
+      this.objects.push(this.object);
+    },
+    finalize: function() {
+      this.object && typeof this.object._finalize == "function" && this.object._finalize(!0);
+    },
+    parseVertexIndex: function(t, s) {
+      const r = parseInt(t, 10);
+      return (r >= 0 ? r - 1 : r + s / 3) * 3;
+    },
+    parseNormalIndex: function(t, s) {
+      const r = parseInt(t, 10);
+      return (r >= 0 ? r - 1 : r + s / 3) * 3;
+    },
+    parseUVIndex: function(t, s) {
+      const r = parseInt(t, 10);
+      return (r >= 0 ? r - 1 : r + s / 2) * 2;
+    },
+    addVertex: function(t, s, r) {
+      const i = this.vertices, n = this.object.geometry.vertices;
+      n.push(i[t + 0], i[t + 1], i[t + 2]), n.push(i[s + 0], i[s + 1], i[s + 2]), n.push(i[r + 0], i[r + 1], i[r + 2]);
+    },
+    addVertexPoint: function(t) {
+      const s = this.vertices;
+      this.object.geometry.vertices.push(s[t + 0], s[t + 1], s[t + 2]);
+    },
+    addVertexLine: function(t) {
+      const s = this.vertices;
+      this.object.geometry.vertices.push(s[t + 0], s[t + 1], s[t + 2]);
+    },
+    addNormal: function(t, s, r) {
+      const i = this.normals, n = this.object.geometry.normals;
+      n.push(i[t + 0], i[t + 1], i[t + 2]), n.push(i[s + 0], i[s + 1], i[s + 2]), n.push(i[r + 0], i[r + 1], i[r + 2]);
+    },
+    addFaceNormal: function(t, s, r) {
+      const i = this.vertices, n = this.object.geometry.normals;
+      ct.fromArray(i, t), Ae.fromArray(i, s), ht.fromArray(i, r), j.subVectors(ht, Ae), dt.subVectors(ct, Ae), j.cross(dt), j.normalize(), n.push(j.x, j.y, j.z), n.push(j.x, j.y, j.z), n.push(j.x, j.y, j.z);
+    },
+    addColor: function(t, s, r) {
+      const i = this.colors, n = this.object.geometry.colors;
+      i[t] !== void 0 && n.push(i[t + 0], i[t + 1], i[t + 2]), i[s] !== void 0 && n.push(i[s + 0], i[s + 1], i[s + 2]), i[r] !== void 0 && n.push(i[r + 0], i[r + 1], i[r + 2]);
+    },
+    addUV: function(t, s, r) {
+      const i = this.uvs, n = this.object.geometry.uvs;
+      n.push(i[t + 0], i[t + 1]), n.push(i[s + 0], i[s + 1]), n.push(i[r + 0], i[r + 1]);
+    },
+    addDefaultUV: function() {
+      const t = this.object.geometry.uvs;
+      t.push(0, 0), t.push(0, 0), t.push(0, 0);
+    },
+    addUVLine: function(t) {
+      const s = this.uvs;
+      this.object.geometry.uvs.push(s[t + 0], s[t + 1]);
+    },
+    addFace: function(t, s, r, i, n, o, c, u, d) {
+      const m = this.vertices.length;
+      let p = this.parseVertexIndex(t, m), g = this.parseVertexIndex(s, m), f = this.parseVertexIndex(r, m);
+      if (this.addVertex(p, g, f), this.addColor(p, g, f), c !== void 0 && c !== "") {
+        const h = this.normals.length;
+        p = this.parseNormalIndex(c, h), g = this.parseNormalIndex(u, h), f = this.parseNormalIndex(d, h), this.addNormal(p, g, f);
+      } else
+        this.addFaceNormal(p, g, f);
+      if (i !== void 0 && i !== "") {
+        const h = this.uvs.length;
+        p = this.parseUVIndex(i, h), g = this.parseUVIndex(n, h), f = this.parseUVIndex(o, h), this.addUV(p, g, f), this.object.geometry.hasUVIndices = !0;
+      } else
+        this.addDefaultUV();
+    },
+    addPointGeometry: function(t) {
+      this.object.geometry.type = "Points";
+      const s = this.vertices.length;
+      for (let r = 0, i = t.length; r < i; r++) {
+        const n = this.parseVertexIndex(t[r], s);
+        this.addVertexPoint(n), this.addColor(n);
+      }
+    },
+    addLineGeometry: function(t, s) {
+      this.object.geometry.type = "Line";
+      const r = this.vertices.length, i = this.uvs.length;
+      for (let n = 0, o = t.length; n < o; n++)
+        this.addVertexLine(this.parseVertexIndex(t[n], r));
+      for (let n = 0, o = s.length; n < o; n++)
+        this.addUVLine(this.parseUVIndex(s[n], i));
+    }
+  };
+  return e.startObject("", !1), e;
+}
+class us extends Ut {
   /**
-   * Конструктор рендерера
-   * @param canvas - HTMLCanvasElement для рендеринга
+   * Constructs a new OBJ loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
    */
-  constructor(e) {
-    this.canvas = e, this.scene = new a.Scene(), this.scene.background = new a.Color(1710618), this.camera = new a.PerspectiveCamera(
-      45,
-      e.clientWidth / e.clientHeight,
-      0.1,
-      1e3
-    ), this.camera.position.set(1, 1, 7), this.renderer = new a.WebGLRenderer({ canvas: e, antialias: !0 }), this.renderer.setSize(e.clientWidth, e.clientHeight);
-    const s = new a.AmbientLight(16777215, 0.5);
-    this.scene.add(s);
-    const i = new a.DirectionalLight(16777215, 1);
-    i.position.set(5, 10, 7), this.scene.add(i);
+  constructor(t) {
+    super(t), this.materials = null;
   }
   /**
-   * Обновляет размер рендерера и камеры при изменении размеров canvas.
+   * Starts loading from the given URL and passes the loaded OBJ asset
+   * to the `onLoad()` callback.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function(Group)} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+   * @param {onErrorCallback} onError - Executed when errors occur.
    */
-  resize() {
-    this.camera.aspect = this.canvas.clientWidth / this.canvas.clientHeight, this.camera.updateProjectionMatrix(), this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);
+  load(t, s, r, i) {
+    const n = this, o = new Nt(this.manager);
+    o.setPath(this.path), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(t, function(c) {
+      try {
+        s(n.parse(c));
+      } catch (u) {
+        i ? i(u) : console.error(u), n.manager.itemError(t);
+      }
+    }, r, i);
   }
   /**
-   * Выполняет рендеринг сцены с текущей камерой.
+   * Sets the material creator for this OBJ. This object is loaded via {@link MTLLoader}.
+   *
+   * @param {MaterialCreator} materials - An object that creates the materials for this OBJ.
+   * @return {OBJLoader} A reference to this loader.
    */
-  render() {
-    this.renderer.render(this.scene, this.camera);
+  setMaterials(t) {
+    return this.materials = t, this;
   }
   /**
-   * Метод для обновления логики рендерера.
+   * Parses the given OBJ data and returns the resulting group.
+   *
+   * @param {string} text - The raw OBJ data as a string.
+   * @return {Group} The parsed OBJ.
    */
-  update() {
+  parse(t) {
+    const s = new ds();
+    t.indexOf(`\r
+`) !== -1 && (t = t.replace(/\r\n/g, `
+`)), t.indexOf(`\\
+`) !== -1 && (t = t.replace(/\\\n/g, ""));
+    const r = t.split(`
+`);
+    let i = [];
+    for (let c = 0, u = r.length; c < u; c++) {
+      const d = r[c].trimStart();
+      if (d.length === 0) continue;
+      const m = d.charAt(0);
+      if (m !== "#")
+        if (m === "v") {
+          const p = d.split(lt);
+          switch (p[0]) {
+            case "v":
+              s.vertices.push(
+                parseFloat(p[1]),
+                parseFloat(p[2]),
+                parseFloat(p[3])
+              ), p.length >= 7 ? (te.setRGB(
+                parseFloat(p[4]),
+                parseFloat(p[5]),
+                parseFloat(p[6]),
+                wt
+              ), s.colors.push(te.r, te.g, te.b)) : s.colors.push(void 0, void 0, void 0);
+              break;
+            case "vn":
+              s.normals.push(
+                parseFloat(p[1]),
+                parseFloat(p[2]),
+                parseFloat(p[3])
+              );
+              break;
+            case "vt":
+              s.uvs.push(
+                parseFloat(p[1]),
+                parseFloat(p[2])
+              );
+              break;
+          }
+        } else if (m === "f") {
+          const g = d.slice(1).trim().split(lt), f = [];
+          for (let v = 0, y = g.length; v < y; v++) {
+            const A = g[v];
+            if (A.length > 0) {
+              const S = A.split("/");
+              f.push(S);
+            }
+          }
+          const h = f[0];
+          for (let v = 1, y = f.length - 1; v < y; v++) {
+            const A = f[v], S = f[v + 1];
+            s.addFace(
+              h[0],
+              A[0],
+              S[0],
+              h[1],
+              A[1],
+              S[1],
+              h[2],
+              A[2],
+              S[2]
+            );
+          }
+        } else if (m === "l") {
+          const p = d.substring(1).trim().split(" ");
+          let g = [];
+          const f = [];
+          if (d.indexOf("/") === -1)
+            g = p;
+          else
+            for (let h = 0, v = p.length; h < v; h++) {
+              const y = p[h].split("/");
+              y[0] !== "" && g.push(y[0]), y[1] !== "" && f.push(y[1]);
+            }
+          s.addLineGeometry(g, f);
+        } else if (m === "p") {
+          const g = d.slice(1).trim().split(" ");
+          s.addPointGeometry(g);
+        } else if ((i = as.exec(d)) !== null) {
+          const p = (" " + i[0].slice(1).trim()).slice(1);
+          s.startObject(p);
+        } else if (cs.test(d))
+          s.object.startMaterial(d.substring(7).trim(), s.materialLibraries);
+        else if (ls.test(d))
+          s.materialLibraries.push(d.substring(7).trim());
+        else if (hs.test(d))
+          console.warn('THREE.OBJLoader: Rendering identifier "usemap" not supported. Textures must be defined in MTL files.');
+        else if (m === "s") {
+          if (i = d.split(" "), i.length > 1) {
+            const g = i[1].trim().toLowerCase();
+            s.object.smooth = g !== "0" && g !== "off";
+          } else
+            s.object.smooth = !0;
+          const p = s.object.currentMaterial();
+          p && (p.smooth = s.object.smooth);
+        } else {
+          if (d === "\0") continue;
+          console.warn('THREE.OBJLoader: Unexpected line: "' + d + '"');
+        }
+    }
+    s.finalize();
+    const n = new Xt();
+    if (n.materialLibraries = [].concat(s.materialLibraries), !(s.objects.length === 1 && s.objects[0].geometry.vertices.length === 0) === !0)
+      for (let c = 0, u = s.objects.length; c < u; c++) {
+        const d = s.objects[c], m = d.geometry, p = d.materials, g = m.type === "Line", f = m.type === "Points";
+        let h = !1;
+        if (m.vertices.length === 0) continue;
+        const v = new it();
+        v.setAttribute("position", new X(m.vertices, 3)), m.normals.length > 0 && v.setAttribute("normal", new X(m.normals, 3)), m.colors.length > 0 && (h = !0, v.setAttribute("color", new X(m.colors, 3))), m.hasUVIndices === !0 && v.setAttribute("uv", new X(m.uvs, 2));
+        const y = [];
+        for (let S = 0, x = p.length; S < x; S++) {
+          const b = p[S], C = b.name + "_" + b.smooth + "_" + h;
+          let M = s.materials[C];
+          if (this.materials !== null) {
+            if (M = this.materials.create(b.name), g && M && !(M instanceof Se)) {
+              const I = new Se();
+              nt.prototype.copy.call(I, M), I.color.copy(M.color), M = I;
+            } else if (f && M && !(M instanceof ee)) {
+              const I = new ee({ size: 10, sizeAttenuation: !1 });
+              nt.prototype.copy.call(I, M), I.color.copy(M.color), I.map = M.map, M = I;
+            }
+          }
+          M === void 0 && (g ? M = new Se() : f ? M = new ee({ size: 1, sizeAttenuation: !1 }) : M = new Yt(), M.name = b.name, M.flatShading = !b.smooth, M.vertexColors = h, s.materials[C] = M), y.push(M);
+        }
+        let A;
+        if (y.length > 1) {
+          for (let S = 0, x = p.length; S < x; S++) {
+            const b = p[S];
+            v.addGroup(b.groupStart, b.groupCount, S);
+          }
+          g ? A = new ot(v, y) : f ? A = new we(v, y) : A = new at(v, y);
+        } else
+          g ? A = new ot(v, y[0]) : f ? A = new we(v, y[0]) : A = new at(v, y[0]);
+        A.name = d.name, n.add(A);
+      }
+    else if (s.vertices.length > 0) {
+      const c = new ee({ size: 1, sizeAttenuation: !1 }), u = new it();
+      u.setAttribute("position", new X(s.vertices, 3)), s.colors.length > 0 && s.colors[0] !== void 0 && (u.setAttribute("color", new X(s.colors, 3)), c.vertexColors = !0);
+      const d = new we(u, c);
+      n.add(d);
+    }
+    return n;
   }
+}
+const Me = 16776960, xe = 16755200, _s = 2236962, ps = 2236962, ms = {
   /**
-   * Запускает основной цикл рендеринга.
+   * Плоскость (PlaneGeometry)
+   * @returns Плоскость размером 1x1 с одной сегментацией
    */
-  loop() {
-    this.update(), this.render(), requestAnimationFrame(() => this.loop());
-  }
+  [L.Plane]: () => new l.PlaneGeometry(1, 1, 1, 1),
   /**
-   * Добавление фигуры на сцену.
-   * @param figure - Данные фигуры: position, normal, uv
+   * Куб (BoxGeometry)
+   * @returns Куб размером 1x1x1 с одной сегментацией по каждой оси
    */
-  addFigure(e) {
-    const s = new a.BufferGeometry();
-    s.setAttribute("position", new a.Float32BufferAttribute(e.position, 3)), e.normal && s.setAttribute("normal", new a.Float32BufferAttribute(e.normal, 3)), e.uv && s.setAttribute("uv", new a.Float32BufferAttribute(e.uv, 2));
-    const i = new a.Mesh(s, ze);
-    return this.scene.add(i), this.meshes.push(i), i;
+  [L.Cube]: () => new l.BoxGeometry(1, 1, 1, 1, 1, 1),
+  /**
+   * Сфера (SphereGeometry)
+   * @returns Сфера радиусом 0.5, 32 сегмента по ширине, 16 по высоте
+   */
+  [L.Sphere]: () => new l.SphereGeometry(0.5, 32, 16),
+  /**
+   * UV-сфера (SphereGeometry) с гладкой поверхностью
+   * @returns Сфера радиусом 0.5, 32 сегмента по ширине, 16 по высоте
+   */
+  [L.UVSphere]: () => new l.SphereGeometry(0.5, 32, 16),
+  /**
+   * Икосфера (IcosahedronGeometry) — сфера из треугольников
+   * @returns Икосфера радиусом 0.5, уровень детализации 0
+   */
+  [L.Icosphere]: () => new l.IcosahedronGeometry(0.5, 0),
+  /**
+   * Цилиндр (CylinderGeometry)
+   * @returns Цилиндр радиусом 0.5, высотой 1, 32 сегмента
+   */
+  [L.Cylinder]: () => new l.CylinderGeometry(0.5, 0.5, 1, 32, 1, !1),
+  /**
+   * Конус (ConeGeometry)
+   * @returns Конус радиусом 0.5, высотой 1, 32 сегмента
+   */
+  [L.Cone]: () => new l.ConeGeometry(0.5, 1, 32, 1, !1),
+  /**
+   * Пирамида с квадратным основанием.
+   * @returns Пирамида высотой 1 и радиусом основания 0.5
+   */
+  [L.Pyramid]: () => new l.ConeGeometry(0.5, 1, 4, 1, !1),
+  /**
+   * Тетраэдр (TetrahedronGeometry)
+   * @returns Тетраэдр радиусом 0.5
+   */
+  [L.Tetrahedron]: () => new l.TetrahedronGeometry(0.5, 0),
+  /**
+   * Октаэдр (OctahedronGeometry)
+   * @returns Октаэдр радиусом 0.5
+   */
+  [L.Octahedron]: () => new l.OctahedronGeometry(0.5, 0),
+  /**
+   * Додекаэдр (DodecahedronGeometry)
+   * @returns Додекаэдр радиусом 0.5
+   */
+  [L.Dodecahedron]: () => new l.DodecahedronGeometry(0.5, 0),
+  /**
+   * Тор (TorusGeometry)
+   * @returns Тор радиусом 0.5, толщиной 0.2, 16 сегментов по радиусу, 64 по трубке
+   */
+  [L.Torus]: () => new l.TorusGeometry(0.5, 0.2, 16, 64),
+  /**
+   * Тор-кнот (TorusKnotGeometry)
+   * @returns Тор-кнот радиусом 0.4 и толщиной 0.12
+   */
+  [L.TorusKnot]: () => new l.TorusKnotGeometry(0.4, 0.12, 96, 16),
+  /**
+   * Круг (CircleGeometry)
+   * @returns Круг радиусом 0.5, 32 сегмента
+   */
+  [L.Circle]: () => new l.CircleGeometry(0.5, 32),
+  /**
+   * Кольцо (RingGeometry)
+   * @returns Кольцо с внутренним радиусом 0.25 и внешним радиусом 0.5
+   */
+  [L.Ring]: () => new l.RingGeometry(0.25, 0.5, 32),
+  /**
+   * Капсула (CapsuleGeometry)
+   * @returns Капсула радиусом 0.3 и длиной 0.8
+   */
+  [L.Capsule]: () => new l.CapsuleGeometry(0.3, 0.8, 8, 16),
+  /**
+   * Кастомная геометрия (не реализовано в фабрике)
+   * @throws {Error} Всегда выбрасывает ошибку
+   */
+  [L.Custom]: function() {
+    throw new Error("Custom geometry is not generated here.");
+  }
+}, Ot = new l.MeshStandardMaterial({
+  color: 12566463,
+  metalness: 0,
+  roughness: 0.6
+}), gs = 8, z = 0, Ct = 1, It = 2, $ = 31, fs = 0.03, vs = 0.05, et = (e) => !!e && e.isMesh, Pt = (e) => {
+  let t = e;
+  for (; t; ) {
+    if (t.isMesh) return t;
+    t = t.parent;
+  }
+  return null;
+}, Lt = (e) => {
+  const t = new l.BufferGeometry();
+  t.setAttribute("position", e.getAttribute("position")), t.computeBoundingSphere(), t.computeBoundingBox();
+  const s = new l.PointsMaterial({
+    color: ps,
+    size: 6,
+    sizeAttenuation: !1,
+    depthTest: !1,
+    depthWrite: !1,
+    transparent: !0,
+    opacity: 0.9
+  }), r = new l.Points(t, s);
+  return r.layers.set(It), r.renderOrder = 1e3, r.visible = !1, r;
+}, Et = (e) => {
+  const t = new l.EdgesGeometry(e), s = new l.LineSegments(
+    t,
+    new l.LineBasicMaterial({ color: _s, linewidth: 1 })
+  );
+  return s.layers.set(Ct), s;
+}, ys = (e) => {
+  const t = { x: e.position.x, y: e.position.y, z: e.position.z }, s = { x: e.rotation.x, y: e.rotation.y, z: e.rotation.z }, r = { x: e.scale.x, y: e.scale.y, z: e.scale.z }, i = new l.Box3().setFromObject(e), n = new l.Vector3();
+  i.getSize(n);
+  const o = { x: n.x, y: n.y, z: n.z };
+  return { position: t, rotation: s, scale: r, size: o };
+}, Tt = (e, t) => t ? {
+  background: {
+    ...e.background,
+    ...t.background
+  },
+  camera: {
+    ...e.camera,
+    ...t.camera,
+    position: {
+      ...e.camera.position,
+      ...t.camera?.position
+    }
+  },
+  renderer: {
+    ...e.renderer,
+    ...t.renderer
+  },
+  lights: {
+    ambient: {
+      ...e.lights.ambient,
+      ...t.lights?.ambient
+    },
+    directional: {
+      ...e.lights.directional,
+      ...t.lights?.directional,
+      position: {
+        ...e.lights.directional.position,
+        ...t.lights?.directional?.position
+      }
+    }
+  }
+} : e, Y = (e) => (e.userData.isProxy = !0, e.userData.isExportable = !1, e), N = (e) => (e.userData.isExportable = !1, e), Vt = (e) => e.userData.isProxy === !0, bs = (e) => {
+  let t = e;
+  for (; t; ) {
+    if (t.userData.isExportable === !1)
+      return !0;
+    t = t.parent;
+  }
+  return !1;
+}, Ms = (e) => !et(e) || !e.visible || Vt(e) || bs(e) ? !1 : e.userData.isExportable !== !1, xs = (e) => {
+  const t = new l.Group();
+  return t.name = "Planara_OBJ_Export", e.updateMatrixWorld(!0), e.traverse((s) => {
+    if (!Ms(s))
+      return;
+    const r = s.clone(!1);
+    r.geometry = s.geometry.clone(), Array.isArray(s.material) ? r.material = s.material.map((i) => i.clone()) : r.material = s.material.clone(), r.matrix.copy(s.matrixWorld), r.matrixAutoUpdate = !1, t.add(r);
+  }), t;
+}, Dt = (e) => {
+  const s = new us().parse(e);
+  s.updateMatrixWorld(!0);
+  const r = [];
+  return s.traverse((i) => {
+    if (!et(i))
+      return;
+    const n = i.geometry.clone();
+    n.applyMatrix4(i.matrixWorld), n.computeBoundingBox();
+    const o = n.boundingBox;
+    if (!o)
+      return;
+    const c = new l.Vector3();
+    o.getCenter(c), n.translate(-c.x, -c.y, -c.z), n.computeBoundingBox(), n.computeBoundingSphere(), n.computeVertexNormals();
+    const u = n.getAttribute("position");
+    u && u.setUsage && u.setUsage(l.DynamicDrawUsage);
+    const d = new l.Mesh(n, Ot.clone());
+    d.position.copy(c), d.layers.enable(z);
+    const m = n.index ? n.toNonIndexed() : n, p = N(Et(m));
+    p.layers.enable(z), d.add(p);
+    const g = N(Lt(m));
+    g.layers.enable(z), d.add(g), r.push(d);
+  }), r;
+}, jt = {
+  background: {
+    color: 1710618,
+    transparent: !1
+  },
+  camera: {
+    fov: 45,
+    near: 0.1,
+    far: 1e3,
+    position: {
+      x: 1,
+      y: 1,
+      z: 7
+    }
+  },
+  renderer: {
+    antialias: !0,
+    alpha: !1
+  },
+  lights: {
+    ambient: {
+      enabled: !0,
+      color: 16777215,
+      intensity: 0.5
+    },
+    directional: {
+      enabled: !0,
+      color: 16777215,
+      intensity: 1,
+      position: {
+        x: 5,
+        y: 10,
+        z: 7
+      }
+    }
   }
+};
+var Ss = Object.getOwnPropertyDescriptor, ws = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Ss(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, ut = (e, t) => (s, r) => t(s, r, e);
+let ae = class {
   /**
-   * Добавляет фигуру в сцену и сохраняет его во внутреннем массиве.
+   * Конструктор рендерера.
    *
-   * @param mesh - Фигура для добавления в сцену.
-   * @internal
+   * @param _canvas - HTMLCanvasElement для рендеринга
+   * @param _config - Конфиг для настройки рендерера
+   *
+   * @remarks
+   * Инициализирует сцену, камеру, WebGLRenderer и базовое освещение
+   * на основе переданного `RendererConfig`.
+   *
+   * По умолчанию используется тёмный фон, перспективная камера
+   * и два источника света: AmbientLight и DirectionalLight.
+   *
+   * @public
+   * @constructor
    */
-  addMesh(e) {
-    this.scene && (this.scene.add(e), this.meshes.push(e));
+  constructor(e, t) {
+    if (this._config = t, this.canvas = e, this.scene = new l.Scene(), this._config.background.transparent ? this.scene.background = null : this.scene.background = new l.Color(this._config.background.color), this.camera = new l.PerspectiveCamera(
+      this._config.camera.fov,
+      this.canvas.clientWidth / this.canvas.clientHeight,
+      this._config.camera.near,
+      this._config.camera.far
+    ), this.camera.position.set(
+      this._config.camera.position.x,
+      this._config.camera.position.y,
+      this._config.camera.position.z
+    ), this.renderer = new l.WebGLRenderer({
+      canvas: this.canvas,
+      antialias: this._config.renderer.antialias,
+      alpha: this._config.background.transparent || this._config.renderer.alpha
+    }), this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight), this._config.background.transparent ? this.renderer.setClearAlpha(0) : this.renderer.setClearColor(this._config.background.color, 1), this._config.lights.ambient.enabled) {
+      const s = new l.AmbientLight(
+        this._config.lights.ambient.color,
+        this._config.lights.ambient.intensity
+      );
+      this.scene.add(N(s));
+    }
+    if (this._config.lights.directional.enabled) {
+      const s = new l.DirectionalLight(
+        this._config.lights.directional.color,
+        this._config.lights.directional.intensity
+      );
+      s.position.set(
+        this._config.lights.directional.position.x,
+        this._config.lights.directional.position.y,
+        this._config.lights.directional.position.z
+      ), this.scene.add(N(s));
+    }
   }
   /**
-   * Убирает фигуру со сцены
+   * Корневой объект сцены Three.js.
    *
-   * @param mesh - Фигура для удаления со сцены.
-   * @internal
+   * @protected
+   * @member
    */
-  removeMesh(e) {
-    this.scene && (this.scene.remove(e), this.meshes = this.meshes.filter((s) => s !== e));
-  }
+  scene;
   /**
-   * Возвращает список всех фигур, находящихся в сцене.
+   * Камера для сцены Three.js.
    *
-   * @returns Массив текущих фигур.
-   * @internal
+   * @protected
+   * @member
    */
-  getMeshes() {
-    return this.meshes;
-  }
+  camera;
   /**
-   * Добавляет объект в сцену и (опционально) выставляет ему слой.
+   * Экземпляр Three.js WebGLRenderer.
    *
-   * @param obj - Объект, который нужно добавить в сцену.
-   * @param layer - (Опц.) Номер слоя, который следует установить объекту перед добавлением.
+   * @protected
+   * @member
+   */
+  renderer;
+  /**
+   * HTML-элемент canvas, на котором рендерится сцена.
+   *
+   * @protected
+   * @member
+   */
+  canvas;
+  /**
+   * Обновляет размер рендерера и пропорции камеры.
    *
    * @remarks
-   * Если рендерер уже диспоузнут (scene отсутствует), метод тихо завершится.
-   * Слой задаётся через `obj.layers.set(layer)`, после чего объект добавляется в `this.scene`.
+   * Вызывается при изменении размеров canvas (например, при ресайзе окна браузера).
    *
    * @example
-   * // Добавить оверлей на слой подсветок:
-   * add(overlayLine, OVERLAY_LAYER);
+   * ```typescript
+   * window.addEventListener('resize', () => renderer.resize());
+   * ```
    *
-   * @internal
+   * @public
+   * @method
    */
-  addObject(e, s) {
-    this.scene && (typeof s == "number" && e.layers.set(s), this.scene.add(e));
+  resize() {
+    this.camera.aspect = this.canvas.clientWidth / this.canvas.clientHeight, this.camera.updateProjectionMatrix(), this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);
   }
   /**
-   * Удаляет объект из сцены (или из его родителя, если он есть).
-   *
-   * @param obj - Объект, который необходимо удалить.
+   * Выполняет рендеринг текущего кадра.
    *
    * @remarks
-   * Если у объекта есть `parent`, он будет удалён из родителя. Иначе — метод попытается
-   * удалить его напрямую из `this.scene`. В рамках данного API метод не отвечает за
-   * освобождение GPU-ресурсов; освобождайте геометрию/материалы отдельно при необходимости.
+   * Рендерит сцену с текущей камерой.
+   * Вызывается автоматически в цикле `loop()`.
    *
-   * @example
-   * // Снять оверлей со сцены:
-   * removeObject(overlayLine);
-   *
-   * @internal
+   * @public
+   * @method
    */
-  removeObject(e) {
-    this.scene && (e.parent ? e.parent.remove(e) : this.scene.remove(e));
+  render() {
+    this.renderer.render(this.scene, this.camera);
   }
   /**
-   * Включает указанный слой у активной камеры.
+   * Обновляет состояние рендерера перед рендерингом.
+   *
+   * @remarks
+   * Пустой метод, предназначен для переопределения в наследниках
+   * (например, для обновления контролов камеры).
    *
-   * @param layer - Номер слоя, который требуется сделать видимым для камеры.
+   * @protected
+   * @method
+   * @virtual
+   */
+  update() {
+  }
+  /**
+   * Запускает основной цикл рендеринга.
    *
    * @remarks
-   * Полезно для показа служебных оверлеев (например, подсветки) на отдельном слое.
-   * Метод не изменяет слои Raycaster — ими должен управлять другой слой API (например, IRaycastAPI).
+   * Вызывает `update()` и `render()` каждый кадр с помощью `requestAnimationFrame`.
+   * **Важно:** вызывать метод только один раз.
    *
    * @example
-   * // Убедиться, что камера видит слой оверлеев:
-   * enableCameraLayer(OVERLAY_LAYER);
+   * ```typescript
+   * renderer.loop();
+   * ```
    *
-   * @internal
+   * @public
+   * @method
    */
-  enableCameraLayer(e) {
-    this.camera && this.camera.layers.enable(e);
-  }
-  /** Освобождает ресурсы рендерера, очищает внутренние данные. */
-  dispose() {
-    this.meshes && (this.meshes.length = 0, this.meshes = []), this.scene = null, this.camera = null, this.renderer?.dispose(), this.canvas = null;
-  }
-}
-var ct = Object.getOwnPropertyDescriptor, dt = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? ct(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-};
-let Q = class {
-  _emitter;
-  constructor() {
-    this._emitter = new nt();
+  loop() {
+    this.update(), this.render(), requestAnimationFrame(() => this.loop());
   }
-  /** Публикация события */
-  emit(t, e) {
-    this._emitter.emit(t, e);
+  getCamera() {
+    return this.camera;
   }
-  /** Подписка на событие */
-  on(t, e) {
-    this._emitter.on(t, e);
+  getRenderer() {
+    return this.renderer;
   }
-  /** Отписка от события */
-  off(t, e) {
-    this._emitter.off(t, e);
+  getCanvas() {
+    return this.canvas;
   }
-};
-Q = dt([
-  M()
-], Q);
-var H = /* @__PURE__ */ ((t) => (t.SelectHover = "select.hover", t.SelectClick = "select.click", t.ToolSelect = "tool.select", t))(H || {});
-const _t = 0.03, ut = 0.05, J = 0, pt = 1, mt = 2, T = 31, Z = 16776960, X = 16755200, ft = 2236962, gt = 2236962, bt = (t) => !!t && t.isMesh, Ye = (t) => {
-  let e = t;
-  for (; e; ) {
-    if (e.isMesh) return e;
-    e = e.parent;
+  getDomElement() {
+    return this.renderer.domElement;
   }
-  return null;
-}, $e = (t) => {
-  const e = new a.BufferGeometry();
-  e.setAttribute("position", t.getAttribute("position")), e.computeBoundingSphere(), e.computeBoundingBox();
-  const s = new a.PointsMaterial({
-    color: gt,
-    size: 6,
-    sizeAttenuation: !1,
-    depthTest: !1,
-    depthWrite: !1,
-    transparent: !0,
-    opacity: 0.9
-  }), i = new a.Points(e, s);
-  return i.layers.set(mt), i.renderOrder = 1e3, i.visible = !1, i;
-}, Ue = (t) => {
-  const e = new a.EdgesGeometry(t), s = new a.LineSegments(
-    e,
-    new a.LineBasicMaterial({ color: ft, linewidth: 1 })
-  );
-  return s.layers.set(pt), s;
-}, vt = (t) => {
-  const e = { x: t.position.x, y: t.position.y, z: t.position.z }, s = { x: t.rotation.x, y: t.rotation.y, z: t.rotation.z }, i = { x: t.scale.x, y: t.scale.y, z: t.scale.z }, r = new a.Box3().setFromObject(t), o = new a.Vector3();
-  r.getSize(o);
-  const n = { x: o.x, y: o.y, z: o.z };
-  return { position: e, rotation: s, scale: i, size: n };
-};
-var yt = Object.getOwnPropertyDescriptor, Mt = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? yt(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Oe = (t, e) => (s, i) => e(s, i, t);
-let ee = class extends Ne {
-  constructor(t, e) {
-    super(t), this._canvas = t, this._bus = e;
-    const s = new a.GridHelper(10, 10);
-    s.position.y = -1e-3, this.scene.add(s);
-    const i = new tt(6);
-    this.scene.add(i), this._orbit = new st(this.camera, this.renderer.domElement), this._orbit.enableDamping = !0, this._orbit.dampingFactor = 0.05, this._cameraGizmo = new it(this.renderer, this.camera, {
-      size: 96,
-      // Размер квадрата
-      margin: 36
-      // Отступы по сторонам (снизу и справа)
-    }), this._raycaster = new a.Raycaster(), this._mouse = new a.Vector2(), this.scene.add(new a.HemisphereLight(16777215, 4473924, 0.6)), this.camera.layers.enable(0), this.camera.layers.enable(1), this._transform = new rt(this.camera, this.renderer.domElement), this._transformHelper = this._transform.getHelper(), this.scene.add(this._transformHelper), this._isEventListenersAdded || this._initMouseListeners();
+  getScene() {
+    return this.scene;
   }
-  /** Orbit-контроллер для управления камерой */
-  _orbit;
-  /** Transform-контроллер для редактирования */
-  _transform;
-  _transformHelper;
-  /** Raycast для получения событий наведения/клика по модели*/
-  _raycaster;
-  /** Курсор мыши */
-  _mouse;
-  /** Были ли инициализированы обработчики событий (hover/click) */
-  _isEventListenersAdded = !1;
   /**
-   * Ключ последней модели, на которую наводились,
-   * необходима для отправки только уникальных событий в event bus
+   * Освобождает ресурсы рендерера.
+   *
+   * @remarks
+   * Удаляет ссылки на сцену, камеру и canvas, вызывает `dispose()` у WebGLRenderer.
+   * Вызывается при уничтожении редактора IOC-контейнером.
+   *
+   * @public
+   * @method
    */
-  _lastHoverKey = null;
-  _currentRaycastMode = y.Mesh;
-  /** Gizmo для управления отображением perspective camera */
-  _cameraGizmo;
-  _transformListeners = /* @__PURE__ */ new Set();
+  dispose() {
+    this.scene = null, this.camera = null, this.renderer?.dispose(), this.canvas = null;
+  }
+};
+ae = ws([
+  w(),
+  ut(0, _("Canvas")),
+  ut(1, _("RendererConfig"))
+], ae);
+class mi {
+  /** Позиции вершин */
+  _positions = [];
+  /** Нормали вершин */
+  _normals = [];
+  /** UV-координаты (опционально) */
+  _uvs = [];
+  // Временные поля для парсинга файла
+  _tmpPositions = [];
+  _tmpNormals = [];
+  _tmpUVs = [];
   /**
-   * Обновление состояния рендерера.
+   * Загружает OBJ-модель в Figure
+   * @param objContent - Строка содержимого .obj файла
    */
-  update() {
-    this._orbit.update();
-  }
-  /** Добавление фигуры на сцену */
-  addFigure(t) {
-    const e = super.addFigure(t);
-    e.layers.enable(J);
-    const s = Ue(e.geometry);
-    e.add(s);
-    const i = $e(e.geometry);
-    return e.add(i), e;
+  load(t) {
+    const s = t.split(`
+`);
+    for (const i of s) {
+      if (!i.trim() || i.startsWith("#")) continue;
+      const n = i.trim().split(/\s+/);
+      switch (n[0]) {
+        case "v":
+          this._tmpPositions.push(n.slice(1).map(Number));
+          break;
+        case "vn":
+          this._tmpNormals.push(n.slice(1).map(Number));
+          break;
+        case "vt":
+          this._tmpUVs.push(n.slice(1).map(Number));
+          break;
+        case "f":
+          this.processFaceLine(n);
+          break;
+      }
+    }
+    const r = {
+      type: L.Custom,
+      position: this._positions,
+      ...this._normals.length > 0 && { normal: this._normals },
+      ...this._uvs.length > 0 && { uv: this._uvs }
+    };
+    return new Qt(r);
   }
   /**
-   * Смена отображения `TransformControls` в зависимости от типа инструмента.
-   * @param mode - тип инструмента для отображения `TransformControls`.
-   * @internal
+   * Обрабатывает строку face (f) и разворачивает индексы в массивы для рендеринга
    */
-  setTransformControlsMode(t) {
-    this._transform.setMode(t);
+  processFaceLine(t) {
+    for (let s = 1; s < t.length; s++) {
+      const r = t[s];
+      if (!r) continue;
+      const [i, n, o] = r.split("/"), c = i ? parseInt(i, 10) : void 0, u = n ? parseInt(n, 10) : void 0, d = o ? parseInt(o, 10) : void 0;
+      if (c !== void 0) {
+        const m = this._tmpPositions[c - 1];
+        m && this._positions.push(...m);
+      }
+      if (u !== void 0) {
+        const m = this._tmpUVs[u - 1];
+        m && this._uvs.push(...m);
+      }
+      if (d !== void 0) {
+        const m = this._tmpNormals[d - 1];
+        m && this._normals.push(...m);
+      }
+    }
   }
+}
+var As = Object.getOwnPropertyDescriptor, Os = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? As(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, se = (e, t) => (s, r) => t(s, r, e);
+let le = class {
   /**
-   * Добавление `TransformControls` к объекту.
-   * @param object - объект, к которому добавляются `TransformControls`.
+   * Конструктор контроллера.
+   *
+   * @param _updatable - модули, требующие обновления каждый кадр
+   * @param _renderable - модули, требующие кастомного рендеринга
+   * @param _runtime - модули, требующие инициализации
+   * @param _renderer - рендерер (должен реализовывать `IRenderable`)
+   *
    * @internal
+   * @constructor
    */
-  attachTransformControls(t) {
-    this._transform.attach(t);
+  constructor(e, t, s, r) {
+    this._updatable = e, this._renderable = t, this._runtime = s, this._renderer = r;
   }
   /**
-   * Удаление `TransformControls` с последнего выбранного объекта.
-   * @internal
+   * ID анимационного цикла (для остановки)
+   *
+   * @private
+   * @member
    */
-  detachTransformControls() {
-    this._transform.detach();
+  _animationId = null;
+  start() {
+    const e = [...this._runtime, ...this._updatable, ...this._renderable];
+    new Set(e).forEach((t) => t.init()), this._loop();
   }
   /**
-   * Подписывает слушателя на изменения трансформации текущего объекта.
-   * @internal
+   * Внутренний анимационный цикл.
+   *
+   * @remarks
+   * Каждый кадр:
+   * 1. Обновляет модули (`update()`)
+   * 2. Рендерит сцену
+   * 3. Рендерит дополнительные модули (`render()`)
+   *
+   * @private
+   * @method
    */
-  onTransformChange(t) {
-    return this._transformListeners.add(t), () => this._transformListeners.delete(t);
+  _loop() {
+    this._updatable.forEach((e) => e.update()), this._renderer.render(), this._renderable.forEach((e) => e.render()), this._animationId = requestAnimationFrame(() => this._loop());
+  }
+  stop() {
+    this._animationId && (cancelAnimationFrame(this._animationId), this._animationId = null);
   }
   /**
-   * Настройка режимов для `Raycaster`.
-   * @internal
+   * Освобождает ресурсы контроллера.
+   *
+   * @public
+   * @method
    */
-  setRaycastMode(t) {
-    const e = this._raycaster;
-    switch (e.params.Line.threshold = 0, e.params.Points.threshold = 0, this._currentRaycastMode = t, this._lastHoverKey = null, t) {
-      case y.Mesh:
-      case y.Face:
-        e.layers.set(0);
-        break;
-      case y.Edge:
-        e.layers.set(1), e.params.Line.threshold = _t;
-        break;
-      case y.Vertex:
-        e.layers.set(2), e.params.Points.threshold = ut;
-        break;
-    }
-  }
   dispose() {
-    this._isEventListenersAdded && (this._canvas.removeEventListener("mousemove", this._handleMouseMove, !1), this._canvas.removeEventListener("click", this._handleMouseClick, !1), this._canvas.removeEventListener("dblclick", this._handleDoubleClick, !1), this._canvas.removeEventListener("pointerdown", (t) => this._transform.pointerDown(t)), this._canvas.removeEventListener("pointermove", (t) => this._transform.pointerMove(t)), this._canvas.removeEventListener("pointerup", (t) => this._transform.pointerUp(t)), this._canvas.removeEventListener("pointerleave", () => this._transform.pointerHover(null)), this._transform.removeEventListener("dragging-changed", () => {
-      this._orbit.enabled = !this._transform.dragging;
-    }), this._transformListeners.clear(), this._isEventListenersAdded = !1), this._orbit?.dispose(), this._transform?.dispose(), this._transformHelper?.parent && this._transformHelper.parent.remove(this._transformHelper), this._lastHoverKey = null, super.dispose();
+    this._animationId = null;
   }
-  render() {
-    super.render(), this._cameraGizmo.render(this._canvas.width, this._canvas.height);
+};
+le = Os([
+  w(),
+  se(0, B("IUpdatableModule", { isOptional: !0 })),
+  se(1, B("IRenderableModule", { isOptional: !0 })),
+  se(2, B("IRuntimeModule", { isOptional: !0 })),
+  se(3, _("IRenderable"))
+], le);
+var Cs = Object.getOwnPropertyDescriptor, Is = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Cs(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Ps = (e, t) => (s, r) => t(s, r, e);
+let Ee = class {
+  /** @constructor */
+  constructor(e) {
+    this._controlsModule = e;
   }
-  /** Инициализация обработчиков событий на hover/click */
-  _initMouseListeners() {
-    this._canvas.addEventListener("mousemove", this._handleMouseMove, !1), this._canvas.addEventListener("click", this._handleMouseClick, !1), this._canvas.addEventListener("dblclick", this._handleDoubleClick, !1), this._canvas.addEventListener("pointerdown", (t) => this._transform.pointerDown(t)), this._canvas.addEventListener("pointermove", (t) => this._transform.pointerMove(t)), this._canvas.addEventListener("pointerup", (t) => this._transform.pointerUp(t)), this._canvas.addEventListener("pointerleave", () => this._transform.pointerHover(null)), this._transform.addEventListener("dragging-changed", () => {
-      this._orbit.enabled = !this._transform.dragging;
-    }), this._transform.addEventListener("objectChange", () => {
-      for (const t of this._transformListeners) t();
-    }), this._isEventListenersAdded = !0;
+  isOrbitInteracting() {
+    return this._controlsModule.isOrbitInteracting();
   }
-  /** Обработчик события для hover */
-  _handleMouseMove = (t) => {
-    this._processRaycastEvent(t, H.SelectHover, !0);
+  isTransformDragging() {
+    return this._controlsModule.isTransformDragging();
+  }
+};
+Ee = Is([
+  w(),
+  Ps(0, _("ControlsModule"))
+], Ee);
+var Ls = Object.getOwnPropertyDescriptor, Es = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Ls(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Ts = (e, t) => (s, r) => t(s, r, e);
+let ce = class {
+  /** @constructor */
+  constructor(e) {
+    this._sceneModule = e;
+  }
+  addMesh(e) {
+    this._sceneModule.addMesh(e);
+  }
+  addMeshes(e) {
+    this._sceneModule.addMeshes(e);
+  }
+  removeMesh(e) {
+    this._sceneModule.removeMesh(e);
+  }
+  removeMeshes(e) {
+    this._sceneModule.removeMeshes(e);
+  }
+  getMeshes() {
+    return this._sceneModule.getMeshes();
+  }
+};
+ce = Es([
+  w(),
+  Ts(0, _("SceneModule"))
+], ce);
+var Vs = Object.getOwnPropertyDescriptor, Ds = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Vs(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, js = (e, t) => (s, r) => t(s, r, e);
+let Te = class {
+  /** @constructor */
+  constructor(e) {
+    this._raycastModule = e;
+  }
+  setRaycastMode(e) {
+    this._raycastModule.setRaycastMode(e);
+  }
+};
+Te = Ds([
+  w(),
+  js(0, _("RaycastModule"))
+], Te);
+var $s = Object.getOwnPropertyDescriptor, Rs = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? $s(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Fs = (e, t) => (s, r) => t(s, r, e);
+let Ve = class {
+  /** @constructor */
+  constructor(e) {
+    this._controlsModule = e;
+  }
+  attachTransform(e) {
+    this._controlsModule.attachTransform(e);
+  }
+  detachTransform() {
+    this._controlsModule.detachTransform();
+  }
+  setTransformMode(e) {
+    this._controlsModule.setTransformMode(e);
+  }
+  onTransformChange(e) {
+    return this._controlsModule.onTransformChange(e);
+  }
+};
+Ve = Rs([
+  w(),
+  Fs(0, _("ControlsModule"))
+], Ve);
+var Hs = Object.getOwnPropertyDescriptor, Bs = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Hs(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, ks = (e, t) => (s, r) => t(s, r, e);
+let he = class {
+  constructor(e) {
+    this._cameraAccessApi = e;
+  }
+  getCamera() {
+    return this._cameraAccessApi.getCamera();
+  }
+  enableCameraLayer(e) {
+    this._cameraAccessApi.getCamera().layers.enable(e);
+  }
+  disableCameraLayer(e) {
+    this._cameraAccessApi.getCamera().layers.disable(e);
+  }
+};
+he = Bs([
+  w(),
+  ks(0, _("IRendererCameraAccess"))
+], he);
+var zs = Object.getOwnPropertyDescriptor, Gs = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? zs(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Ws = (e, t) => (s, r) => t(s, r, e);
+let de = class {
+  constructor(e) {
+    this._domAccessApi = e;
+  }
+  getCanvas() {
+    return this._domAccessApi.getCanvas();
+  }
+  getDomElement() {
+    return this._domAccessApi.getDomElement();
+  }
+};
+de = Gs([
+  w(),
+  Ws(0, _("IRendererDomAccess"))
+], de);
+var Us = Object.getOwnPropertyDescriptor, Ns = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Us(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Xs = (e, t) => (s, r) => t(s, r, e);
+let ue = class {
+  constructor(e) {
+    this._sceneAccessApi = e;
+  }
+  getScene() {
+    return this._sceneAccessApi.getScene();
+  }
+  addToScene(e) {
+    this._sceneAccessApi.getScene().add(e);
+  }
+  removeFromScene(e) {
+    this._sceneAccessApi.getScene().remove(e);
+  }
+  addObject(e, t) {
+    const s = this._sceneAccessApi.getScene();
+    s && (typeof t == "number" && e.layers.set(t), s.add(e));
+  }
+};
+ue = Ns([
+  w(),
+  Xs(0, _("IRendererSceneAccess"))
+], ue);
+var Ys = Object.getOwnPropertyDescriptor, qs = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Ys(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Oe = (e, t) => (s, r) => t(s, r, e);
+let _e = class {
+  constructor(e, t, s) {
+    this._cameraApi = e, this._domApi = t, this._sceneApi = s;
+  }
+  /** Orbit-контроллер для управления камерой */
+  _orbit = null;
+  /** Transform-контроллер для редактирования */
+  _transform = null;
+  _transformHelper = null;
+  _transformListeners = /* @__PURE__ */ new Set();
+  /** Были ли инициализированы обработчики событий (hover/click) */
+  _isEventListenersAdded = !1;
+  init() {
+    this._orbit = new ts(this._cameraApi.getCamera(), this._domApi.getDomElement()), this._orbit.enableDamping = !0, this._orbit.dampingFactor = 0.05, this._transform = new ss(
+      this._cameraApi.getCamera(),
+      this._domApi.getDomElement()
+    ), this._transformHelper = this._transform.getHelper(), this._sceneApi.addToScene(N(this._transformHelper)), this._initMouseListeners();
+  }
+  attachTransform(e) {
+    this._transform?.attach(e);
+  }
+  detachTransform() {
+    this._transform?.detach();
+  }
+  update() {
+    this._orbit?.update();
+  }
+  setTransformMode(e) {
+    this._transform?.setMode(e);
+  }
+  onTransformChange(e) {
+    return this._transformListeners.add(e), () => this._transformListeners.delete(e);
+  }
+  isOrbitInteracting() {
+    return !!this._orbit?.isInteracting;
+  }
+  isTransformDragging() {
+    return !!this._transform?.dragging;
+  }
+  _handlePointerDown = (e) => {
+    this._transform?.pointerDown(e);
   };
-  /** Обработчик события на click */
-  _handleMouseClick = (t) => {
-    this._processRaycastEvent(t, H.SelectClick, !1);
+  _handlePointerMove = (e) => {
+    this._transform?.pointerMove(e);
   };
-  /** Возвращает ближайшее пересечение по текущему положению курсора */
-  _getHitIntersection(t) {
-    if (this._orbit.isInteracting || this._transform.dragging) return;
-    const e = this._canvas.getBoundingClientRect();
-    this._mouse.x = (t.clientX - e.left) / e.width * 2 - 1, this._mouse.y = -((t.clientY - e.top) / e.height) * 2 + 1, this._raycaster.setFromCamera(this._mouse, this.camera);
-    const s = this._raycaster.intersectObjects(this.meshes, !0)[0] ?? null;
-    if (this._currentRaycastMode === y.Mesh || this._currentRaycastMode === y.Face)
-      return s;
-    const i = this._raycaster.layers.mask;
-    this._raycaster.layers.set(J);
-    const r = this._raycaster.intersectObjects(this.meshes, !0)[0] ?? null;
-    return this._raycaster.layers.mask = i, this._getVisibleHit(s, r);
-  }
-  _handleDoubleClick = (t) => {
-    const e = this._getHitIntersection(t);
-    e !== void 0 && (e || this._bus.emit(H.SelectClick, null));
+  _handlePointerUp = (e) => {
+    this._transform?.pointerUp(e);
   };
-  // Hover сравнивается не только по object, но и по режимному ключу попадания.
-  // Это нужно для Face/Edge/Vertex режимов, где разные элементы могут принадлежать одному и тому же Object3D.
-  /** Вспомогательный метод для получения модели, которую выбрали и отправки события в event bus */
-  _processRaycastEvent(t, e, s) {
-    const i = this._getHitIntersection(t);
-    if (i === void 0) return;
-    const r = i?.object ?? null;
-    if (s) {
-      if (!i) {
-        this.meshes.forEach((n) => n.userData.isHit = !1), this._lastHoverKey = null, this._bus.emit(e, null);
-        return;
-      }
-      const o = this._makeHoverKey(i);
-      o !== this._lastHoverKey && (this.meshes.forEach((n) => n.userData.isHit = !1), r && (r.userData.isHit = !0), this._lastHoverKey = o, this._bus.emit(e, { intersection: i }));
-      return;
+  _handlePointerLeave = () => {
+    this._transform?.pointerHover(null);
+  };
+  _handleDraggingChanged = () => {
+    this._orbit && (this._orbit.enabled = !this._transform?.dragging);
+  };
+  _handleObjectChange = () => {
+    for (const e of this._transformListeners)
+      e();
+  };
+  /** Инициализация обработчиков событий на hover/click */
+  _initMouseListeners() {
+    const e = this._domApi.getCanvas();
+    !this._transform || !this._orbit || (e.addEventListener("pointerdown", this._handlePointerDown), e.addEventListener("pointermove", this._handlePointerMove), e.addEventListener("pointerup", this._handlePointerUp), e.addEventListener("pointerleave", this._handlePointerLeave), this._transform.addEventListener("dragging-changed", this._handleDraggingChanged), this._transform.addEventListener("objectChange", this._handleObjectChange), this._isEventListenersAdded = !0);
+  }
+  /** Освобождает ресурсы модуля */
+  dispose() {
+    if (this._isEventListenersAdded) {
+      const e = this._domApi.getCanvas();
+      if (!this._transform || !this._orbit) return;
+      e.removeEventListener("pointerdown", this._handlePointerDown), e.removeEventListener("pointermove", this._handlePointerMove), e.removeEventListener("pointerup", this._handlePointerUp), e.removeEventListener("pointerleave", this._handlePointerLeave), this._transform.removeEventListener("dragging-changed", this._handleDraggingChanged), this._transform.removeEventListener("objectChange", this._handleObjectChange), this._transformListeners.clear(), this._isEventListenersAdded = !1;
     }
-    i && this._bus.emit(e, { intersection: i });
+    this._orbit?.dispose(), this._orbit = null, this._transform?.dispose(), this._transform = null, this._transformHelper?.parent && this._transformHelper.parent.remove(this._transformHelper);
   }
-  /** Поиск видимой части меша
-   * необходимо это для того, чтобы отправлять только видимые элементы модели, а не все попадания
-   */
-  _getVisibleHit(t, e, s = 1e-4) {
-    return t ? e ? t.distance <= e.distance + s ? t : null : t : null;
+};
+_e = qs([
+  w(),
+  Oe(0, _("ICameraApi")),
+  Oe(1, _("IDomApi")),
+  Oe(2, _("ISceneApi"))
+], _e);
+var Zs = Object.getOwnPropertyDescriptor, Ks = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Zs(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Ce = (e, t) => (s, r) => t(s, r, e);
+let De = class {
+  constructor(e, t, s) {
+    this._cameraApi = e, this._domApi = t, this._rendererApi = s;
   }
-  /** Строит ключ hover-пересечения с учетом текущего режима выборки */
-  _makeHoverKey(t) {
-    if (!t) return null;
-    const e = t.object.uuid;
-    switch (this._currentRaycastMode) {
-      case y.Face:
-        return `${e}:face:${t.faceIndex ?? -1}`;
-      case y.Edge:
-        return `${e}:edge:${Math.floor((t.index ?? -1) / 2)}`;
-      case y.Vertex:
-        return `${e}:vertex:${t.index ?? -1}`;
-      case y.Mesh:
-      default:
-        return `${e}:mesh`;
-    }
+  /** Gizmo для управления отображением perspective camera */
+  _cameraGizmo = null;
+  init() {
+    const e = this._cameraApi.getCamera(), t = this._rendererApi.getRenderer();
+    this._cameraGizmo = new rs(t, e, {
+      size: 96,
+      // Размер квадрата
+      margin: 36
+      // Отступы по сторонам (снизу и справа)
+    });
+  }
+  render() {
+    const e = this._domApi.getCanvas();
+    this._cameraGizmo?.render(e.width, e.height);
   }
+  /** Освобождение ресурсов модуля */
+  dispose() {
+    this._cameraGizmo?.dispose(), this._cameraGizmo = null;
+  }
+};
+De = Ks([
+  w(),
+  Ce(0, _("ICameraApi")),
+  Ce(1, _("IDomApi")),
+  Ce(2, _("IRendererAccess"))
+], De);
+var Js = Object.getOwnPropertyDescriptor, Qs = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Js(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
 };
-ee = Mt([
-  M(),
-  Oe(0, _("Canvas")),
-  Oe(1, _("EventBus"))
-], ee);
-const Te = { type: "change" }, be = { type: "start" }, Be = { type: "end" }, B = new qe(), Le = new Qe(), wt = Math.cos(70 * Je.DEG2RAD), v = new I(), P = 2 * Math.PI, p = {
-  NONE: -1,
-  ROTATE: 0,
-  DOLLY: 1,
-  PAN: 2,
-  TOUCH_ROTATE: 3,
-  TOUCH_PAN: 4,
-  TOUCH_DOLLY_PAN: 5,
-  TOUCH_DOLLY_ROTATE: 6
-}, K = 1e-6;
-class St extends Ke {
+let je = class {
   /**
-   * Constructs a new controls instance.
+   * Внутренний эмиттер событий Node.js.
    *
-   * @param {Object3D} object - The object that is managed by the controls.
-   * @param {?HTMLElement} domElement - The HTML element used for event listeners.
+   * @private
+   * @member
    */
-  constructor(e, s = null) {
-    super(e, s), this.state = p.NONE, this.target = new I(), this.cursor = new I(), this.minDistance = 0, this.maxDistance = 1 / 0, this.minZoom = 0, this.maxZoom = 1 / 0, this.minTargetRadius = 0, this.maxTargetRadius = 1 / 0, this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, this.minAzimuthAngle = -1 / 0, this.maxAzimuthAngle = 1 / 0, this.enableDamping = !1, this.dampingFactor = 0.05, this.enableZoom = !0, this.zoomSpeed = 1, this.enableRotate = !0, this.rotateSpeed = 1, this.keyRotateSpeed = 1, this.enablePan = !0, this.panSpeed = 1, this.screenSpacePanning = !0, this.keyPanSpeed = 7, this.zoomToCursor = !1, this.autoRotate = !1, this.autoRotateSpeed = 2, this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" }, this.mouseButtons = { LEFT: Y.ROTATE, MIDDLE: Y.DOLLY, RIGHT: Y.PAN }, this.touches = { ONE: z.ROTATE, TWO: z.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._domElementKeyEvents = null, this._lastPosition = new I(), this._lastQuaternion = new Ee(), this._lastTargetPosition = new I(), this._quat = new Ee().setFromUnitVectors(e.up, new I(0, 1, 0)), this._quatInverse = this._quat.clone().invert(), this._spherical = new xe(), this._sphericalDelta = new xe(), this._scale = 1, this._panOffset = new I(), this._rotateStart = new L(), this._rotateEnd = new L(), this._rotateDelta = new L(), this._panStart = new L(), this._panEnd = new L(), this._panDelta = new L(), this._dollyStart = new L(), this._dollyEnd = new L(), this._dollyDelta = new L(), this._dollyDirection = new I(), this._mouse = new L(), this._performCursorZoom = !1, this._pointers = [], this._pointerPositions = {}, this._controlActive = !1, this._onPointerMove = xt.bind(this), this._onPointerDown = Et.bind(this), this._onPointerUp = Pt.bind(this), this._onContextMenu = It.bind(this), this._onMouseWheel = Lt.bind(this), this._onKeyDown = Dt.bind(this), this._onTouchStart = Ct.bind(this), this._onTouchMove = At.bind(this), this._onMouseDown = Ot.bind(this), this._onMouseMove = Tt.bind(this), this._interceptControlDown = jt.bind(this), this._interceptControlUp = Rt.bind(this), this.domElement !== null && this.connect(this.domElement), this.update();
-  }
-  connect(e) {
-    super.connect(e), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointercancel", this._onPointerUp), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("wheel", this._onMouseWheel, { passive: !1 }), this.domElement.getRootNode().addEventListener("keydown", this._interceptControlDown, { passive: !0, capture: !0 }), this.domElement.style.touchAction = "none";
-  }
-  disconnect() {
-    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointercancel", this._onPointerUp), this.domElement.removeEventListener("wheel", this._onMouseWheel), this.domElement.removeEventListener("contextmenu", this._onContextMenu), this.stopListenToKeyEvents(), this.domElement.getRootNode().removeEventListener("keydown", this._interceptControlDown, { capture: !0 }), this.domElement.style.touchAction = "auto";
+  _emitter;
+  /** @constructor */
+  constructor() {
+    this._emitter = new ns();
   }
-  dispose() {
-    this.disconnect();
+  /**
+   * Публикует событие в шину.
+   *
+   * @param event - название события (из `EventTopics`)
+   * @param payload - данные события (тип зависит от события)
+   *
+   * @typeParam K - ключ события из `EditorEvents`
+   *
+   * @remarks
+   * Все подписчики, зарегистрированные на это событие, получат payload.
+   *
+   * @example
+   * ```typescript
+   * // Публикация события клика
+   * eventBus.emit(EventTopics.SelectClick, { intersection: hit });
+   *
+   * // Публикация события сброса выделения
+   * eventBus.emit(EventTopics.SelectClick, null);
+   * ```
+   *
+   * @public
+   * @method
+   */
+  emit(e, t) {
+    this._emitter.emit(e, t);
   }
   /**
-   * Get the current vertical rotation, in radians.
+   * Подписывается на событие.
+   *
+   * @param event - название события (из `EventTopics`)
+   * @param listener - функция-обработчик, получающая payload
    *
-   * @return {number} The current vertical rotation, in radians.
+   * @typeParam K - ключ события из `EditorEvents`
+   *
+   * @remarks
+   * **Важно:** для предотвращения утечек памяти необходимо отписываться от событий
+   * в `dispose()` методах компонентов.
+   *
+   * @example
+   * ```typescript
+   * // Подписка на событие hover
+   * this._eventBus.on(EventTopics.SelectHover, (payload) => {
+   *   if (payload) {
+   *     this._handleHover(payload.intersection);
+   *   } else {
+   *     this._clearHover();
+   *   }
+   * });
+   * ```
+   *
+   * @public
+   * @method
    */
-  getPolarAngle() {
-    return this._spherical.phi;
+  on(e, t) {
+    this._emitter.on(e, t);
   }
   /**
-   * Get the current horizontal rotation, in radians.
+   * Отписывается от события.
+   *
+   * @param event - название события (из `EventTopics`)
+   * @param listener - функция-обработчик, которую нужно отписать
+   *
+   * @typeParam K - ключ события из `EditorEvents`
+   *
+   * @remarks
+   * Для корректной отписки необходимо передать ту же самую функцию,
+   * которая использовалась при подписке.
+   *
+   * @example
+   * ```typescript
+   * // Сохранение ссылки на обработчик
+   * private _handleClick = (payload) => { ... };
+   *
+   * // Подписка
+   * eventBus.on(EventTopics.SelectClick, this._handleClick);
    *
-   * @return {number} The current horizontal rotation, in radians.
+   * // Отписка (в dispose)
+   * eventBus.off(EventTopics.SelectClick, this._handleClick);
+   * ```
+   *
+   * @public
+   * @method
    */
-  getAzimuthalAngle() {
-    return this._spherical.theta;
+  off(e, t) {
+    this._emitter.off(e, t);
+  }
+};
+je = Qs([
+  w()
+], je);
+var k = /* @__PURE__ */ ((e) => (e.SelectHover = "select.hover", e.SelectClick = "select.click", e))(k || {}), er = Object.getOwnPropertyDescriptor, tr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? er(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, q = (e, t) => (s, r) => t(s, r, e);
+let $e = class {
+  constructor(e, t, s, r, i) {
+    this._domApi = e, this._cameraApi = t, this._meshApi = s, this._controlsState = r, this._bus = i;
   }
   /**
-   * Returns the distance from the camera to the target.
+   * Raycast для получения событий наведения/клика по модели
    *
-   * @return {number} The distance from the camera to the target.
+   * @private
+   * @member
    */
-  getDistance() {
-    return this.object.position.distanceTo(this.target);
-  }
+  _raycaster;
   /**
-   * Adds key event listeners to the given DOM element.
-   * `window` is a recommended argument for using this method.
+   * Курсор мыши
    *
-   * @param {HTMLElement} domElement - The DOM element
+   * @private
+   * @member
    */
-  listenToKeyEvents(e) {
-    e.addEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = e;
-  }
+  _mouse;
   /**
-   * Removes the key event listener previously defined with `listenToKeyEvents()`.
+   * Ключ последней модели, на которую наводились,
+   * необходим для отправки только уникальных событий в event bus
+   *
+   * @private
+   * @member
    */
-  stopListenToKeyEvents() {
-    this._domElementKeyEvents !== null && (this._domElementKeyEvents.removeEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = null);
-  }
+  _lastHoverKey = null;
   /**
-   * Save the current state of the controls. This can later be recovered with `reset()`.
+   * Текущий режим для raycaster
+   *
+   * @private
+   * @member
    */
-  saveState() {
-    this.target0.copy(this.target), this.position0.copy(this.object.position), this.zoom0 = this.object.zoom;
-  }
+  _currentRaycastMode = P.Mesh;
   /**
-   * Reset the controls to their state from either the last time the `saveState()`
-   * was called, or the initial state.
+   * Были ли инициализированы обработчики событий (hover/click)
+   *
+   * @private
+   * @member
    */
-  reset() {
-    this.target.copy(this.target0), this.object.position.copy(this.position0), this.object.zoom = this.zoom0, this.object.updateProjectionMatrix(), this.dispatchEvent(Te), this.update(), this.state = p.NONE;
-  }
-  update(e = null) {
-    const s = this.object.position;
-    v.copy(s).sub(this.target), v.applyQuaternion(this._quat), this._spherical.setFromVector3(v), this.autoRotate && this.state === p.NONE && this._rotateLeft(this._getAutoRotationAngle(e)), this.enableDamping ? (this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor, this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor) : (this._spherical.theta += this._sphericalDelta.theta, this._spherical.phi += this._sphericalDelta.phi);
-    let i = this.minAzimuthAngle, r = this.maxAzimuthAngle;
-    isFinite(i) && isFinite(r) && (i < -Math.PI ? i += P : i > Math.PI && (i -= P), r < -Math.PI ? r += P : r > Math.PI && (r -= P), i <= r ? this._spherical.theta = Math.max(i, Math.min(r, this._spherical.theta)) : this._spherical.theta = this._spherical.theta > (i + r) / 2 ? Math.max(i, this._spherical.theta) : Math.min(r, this._spherical.theta)), this._spherical.phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this._spherical.phi)), this._spherical.makeSafe(), this.enableDamping === !0 ? this.target.addScaledVector(this._panOffset, this.dampingFactor) : this.target.add(this._panOffset), this.target.sub(this.cursor), this.target.clampLength(this.minTargetRadius, this.maxTargetRadius), this.target.add(this.cursor);
-    let o = !1;
-    if (this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera)
-      this._spherical.radius = this._clampDistance(this._spherical.radius);
-    else {
-      const n = this._spherical.radius;
-      this._spherical.radius = this._clampDistance(this._spherical.radius * this._scale), o = n != this._spherical.radius;
-    }
-    if (v.setFromSpherical(this._spherical), v.applyQuaternion(this._quatInverse), s.copy(this.target).add(v), this.object.lookAt(this.target), this.enableDamping === !0 ? (this._sphericalDelta.theta *= 1 - this.dampingFactor, this._sphericalDelta.phi *= 1 - this.dampingFactor, this._panOffset.multiplyScalar(1 - this.dampingFactor)) : (this._sphericalDelta.set(0, 0, 0), this._panOffset.set(0, 0, 0)), this.zoomToCursor && this._performCursorZoom) {
-      let n = null;
-      if (this.object.isPerspectiveCamera) {
-        const h = v.length();
-        n = this._clampDistance(h * this._scale);
-        const l = h - n;
-        this.object.position.addScaledVector(this._dollyDirection, l), this.object.updateMatrixWorld(), o = !!l;
-      } else if (this.object.isOrthographicCamera) {
-        const h = new I(this._mouse.x, this._mouse.y, 0);
-        h.unproject(this.object);
-        const l = this.object.zoom;
-        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), this.object.updateProjectionMatrix(), o = l !== this.object.zoom;
-        const c = new I(this._mouse.x, this._mouse.y, 0);
-        c.unproject(this.object), this.object.position.sub(c).add(h), this.object.updateMatrixWorld(), n = v.length();
-      } else
-        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."), this.zoomToCursor = !1;
-      n !== null && (this.screenSpacePanning ? this.target.set(0, 0, -1).transformDirection(this.object.matrix).multiplyScalar(n).add(this.object.position) : (B.origin.copy(this.object.position), B.direction.set(0, 0, -1).transformDirection(this.object.matrix), Math.abs(this.object.up.dot(B.direction)) < wt ? this.object.lookAt(this.target) : (Le.setFromNormalAndCoplanarPoint(this.object.up, this.target), B.intersectPlane(Le, this.target))));
-    } else if (this.object.isOrthographicCamera) {
-      const n = this.object.zoom;
-      this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), n !== this.object.zoom && (this.object.updateProjectionMatrix(), o = !0);
-    }
-    return this._scale = 1, this._performCursorZoom = !1, o || this._lastPosition.distanceToSquared(this.object.position) > K || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > K || this._lastTargetPosition.distanceToSquared(this.target) > K ? (this.dispatchEvent(Te), this._lastPosition.copy(this.object.position), this._lastQuaternion.copy(this.object.quaternion), this._lastTargetPosition.copy(this.target), !0) : !1;
-  }
-  _getAutoRotationAngle(e) {
-    return e !== null ? P / 60 * this.autoRotateSpeed * e : P / 60 / 60 * this.autoRotateSpeed;
-  }
-  _getZoomScale(e) {
-    const s = Math.abs(e * 0.01);
-    return Math.pow(0.95, this.zoomSpeed * s);
-  }
-  _rotateLeft(e) {
-    this._sphericalDelta.theta -= e;
-  }
-  _rotateUp(e) {
-    this._sphericalDelta.phi -= e;
-  }
-  _panLeft(e, s) {
-    v.setFromMatrixColumn(s, 0), v.multiplyScalar(-e), this._panOffset.add(v);
-  }
-  _panUp(e, s) {
-    this.screenSpacePanning === !0 ? v.setFromMatrixColumn(s, 1) : (v.setFromMatrixColumn(s, 0), v.crossVectors(this.object.up, v)), v.multiplyScalar(e), this._panOffset.add(v);
-  }
-  // deltaX and deltaY are in pixels; right and down are positive
-  _pan(e, s) {
-    const i = this.domElement;
-    if (this.object.isPerspectiveCamera) {
-      const r = this.object.position;
-      v.copy(r).sub(this.target);
-      let o = v.length();
-      o *= Math.tan(this.object.fov / 2 * Math.PI / 180), this._panLeft(2 * e * o / i.clientHeight, this.object.matrix), this._panUp(2 * s * o / i.clientHeight, this.object.matrix);
-    } else this.object.isOrthographicCamera ? (this._panLeft(e * (this.object.right - this.object.left) / this.object.zoom / i.clientWidth, this.object.matrix), this._panUp(s * (this.object.top - this.object.bottom) / this.object.zoom / i.clientHeight, this.object.matrix)) : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."), this.enablePan = !1);
-  }
-  _dollyOut(e) {
-    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale /= e : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
-  }
-  _dollyIn(e) {
-    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale *= e : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
-  }
-  _updateZoomParameters(e, s) {
-    if (!this.zoomToCursor)
-      return;
-    this._performCursorZoom = !0;
-    const i = this.domElement.getBoundingClientRect(), r = e - i.left, o = s - i.top, n = i.width, h = i.height;
-    this._mouse.x = r / n * 2 - 1, this._mouse.y = -(o / h) * 2 + 1, this._dollyDirection.set(this._mouse.x, this._mouse.y, 1).unproject(this.object).sub(this.object.position).normalize();
-  }
-  _clampDistance(e) {
-    return Math.max(this.minDistance, Math.min(this.maxDistance, e));
-  }
-  //
-  // event callbacks - update the object state
-  //
-  _handleMouseDownRotate(e) {
-    this._rotateStart.set(e.clientX, e.clientY);
-  }
-  _handleMouseDownDolly(e) {
-    this._updateZoomParameters(e.clientX, e.clientX), this._dollyStart.set(e.clientX, e.clientY);
-  }
-  _handleMouseDownPan(e) {
-    this._panStart.set(e.clientX, e.clientY);
-  }
-  _handleMouseMoveRotate(e) {
-    this._rotateEnd.set(e.clientX, e.clientY), this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
-    const s = this.domElement;
-    this._rotateLeft(P * this._rotateDelta.x / s.clientHeight), this._rotateUp(P * this._rotateDelta.y / s.clientHeight), this._rotateStart.copy(this._rotateEnd), this.update();
-  }
-  _handleMouseMoveDolly(e) {
-    this._dollyEnd.set(e.clientX, e.clientY), this._dollyDelta.subVectors(this._dollyEnd, this._dollyStart), this._dollyDelta.y > 0 ? this._dollyOut(this._getZoomScale(this._dollyDelta.y)) : this._dollyDelta.y < 0 && this._dollyIn(this._getZoomScale(this._dollyDelta.y)), this._dollyStart.copy(this._dollyEnd), this.update();
-  }
-  _handleMouseMovePan(e) {
-    this._panEnd.set(e.clientX, e.clientY), this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd), this.update();
+  _isEventListenersAdded = !1;
+  init() {
+    this._raycaster = new l.Raycaster(), this._mouse = new l.Vector2(), this._applyRaycastParamsByMode(), this._isEventListenersAdded || (this._initMouseListeners(), this._isEventListenersAdded = !0);
   }
-  _handleMouseWheel(e) {
-    this._updateZoomParameters(e.clientX, e.clientY), e.deltaY < 0 ? this._dollyIn(this._getZoomScale(e.deltaY)) : e.deltaY > 0 && this._dollyOut(this._getZoomScale(e.deltaY)), this.update();
+  setRaycastMode(e) {
+    if (this._currentRaycastMode === e) return;
+    const t = this._raycaster;
+    t.params.Line.threshold = 0, t.params.Points.threshold = 0, this._currentRaycastMode = e, this._lastHoverKey = null, this._applyRaycastParamsByMode();
   }
-  _handleKeyDown(e) {
-    let s = !1;
-    switch (e.code) {
-      case this.keys.UP:
-        e.ctrlKey || e.metaKey || e.shiftKey ? this.enableRotate && this._rotateUp(P * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, this.keyPanSpeed), s = !0;
-        break;
-      case this.keys.BOTTOM:
-        e.ctrlKey || e.metaKey || e.shiftKey ? this.enableRotate && this._rotateUp(-P * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, -this.keyPanSpeed), s = !0;
+  /** Применяет параметры raycaster в зависимости от текущего режима */
+  _applyRaycastParamsByMode() {
+    const e = this._raycaster;
+    switch (e.params.Line.threshold = 0, e.params.Points.threshold = 0, this._currentRaycastMode) {
+      case P.Mesh:
+      case P.Face:
+        e.layers.set(z);
         break;
-      case this.keys.LEFT:
-        e.ctrlKey || e.metaKey || e.shiftKey ? this.enableRotate && this._rotateLeft(P * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(this.keyPanSpeed, 0), s = !0;
+      case P.Edge:
+        e.layers.set(Ct), e.params.Line.threshold = fs;
         break;
-      case this.keys.RIGHT:
-        e.ctrlKey || e.metaKey || e.shiftKey ? this.enableRotate && this._rotateLeft(-P * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(-this.keyPanSpeed, 0), s = !0;
+      case P.Vertex:
+        e.layers.set(It), e.params.Points.threshold = vs;
         break;
     }
-    s && (e.preventDefault(), this.update());
-  }
-  _handleTouchStartRotate(e) {
-    if (this._pointers.length === 1)
-      this._rotateStart.set(e.pageX, e.pageY);
-    else {
-      const s = this._getSecondPointerPosition(e), i = 0.5 * (e.pageX + s.x), r = 0.5 * (e.pageY + s.y);
-      this._rotateStart.set(i, r);
-    }
-  }
-  _handleTouchStartPan(e) {
-    if (this._pointers.length === 1)
-      this._panStart.set(e.pageX, e.pageY);
-    else {
-      const s = this._getSecondPointerPosition(e), i = 0.5 * (e.pageX + s.x), r = 0.5 * (e.pageY + s.y);
-      this._panStart.set(i, r);
-    }
   }
-  _handleTouchStartDolly(e) {
-    const s = this._getSecondPointerPosition(e), i = e.pageX - s.x, r = e.pageY - s.y, o = Math.sqrt(i * i + r * r);
-    this._dollyStart.set(0, o);
+  /** Возвращает ближайшее пересечение по текущему положению курсора */
+  _getHitIntersection(e) {
+    const t = this._controlsState.isOrbitInteracting() || this._controlsState.isTransformDragging(), s = this._domApi.getCanvas(), r = this._cameraApi.getCamera(), i = this._meshApi.getMeshes();
+    if (t) return;
+    const n = s.getBoundingClientRect();
+    this._mouse.x = (e.clientX - n.left) / n.width * 2 - 1, this._mouse.y = -((e.clientY - n.top) / n.height) * 2 + 1, this._raycaster.setFromCamera(this._mouse, r);
+    const o = this._raycaster.intersectObjects(i, !0)[0] ?? null;
+    if (this._currentRaycastMode === P.Mesh || this._currentRaycastMode === P.Face)
+      return o;
+    const c = this._raycaster.layers.mask;
+    this._raycaster.layers.set(z);
+    const u = this._raycaster.intersectObjects(i, !0)[0] ?? null;
+    return this._raycaster.layers.mask = c, this._getVisibleHit(o, u);
   }
-  _handleTouchStartDollyPan(e) {
-    this.enableZoom && this._handleTouchStartDolly(e), this.enablePan && this._handleTouchStartPan(e);
+  // Hover сравнивается не только по object, но и по режимному ключу попадания.
+  // Это нужно для Face/Edge/Vertex режимов, где разные элементы могут принадлежать одному и тому же Object3D.
+  /** Вспомогательный метод для получения модели, которую выбрали и отправки события в event bus */
+  _processRaycastEvent(e, t, s) {
+    const r = this._getHitIntersection(e), i = this._meshApi.getMeshes();
+    if (r === void 0) return;
+    const n = r?.object ?? null;
+    if (s) {
+      if (!r) {
+        i.forEach((c) => c.userData.isHit = !1), this._lastHoverKey = null, this._bus.emit(t, null);
+        return;
+      }
+      const o = this._makeHoverKey(r);
+      o !== this._lastHoverKey && (i.forEach((c) => c.userData.isHit = !1), n && (n.userData.isHit = !0), this._lastHoverKey = o, this._bus.emit(t, { intersection: r }));
+      return;
+    }
+    r && this._bus.emit(t, { intersection: r });
   }
-  _handleTouchStartDollyRotate(e) {
-    this.enableZoom && this._handleTouchStartDolly(e), this.enableRotate && this._handleTouchStartRotate(e);
+  /** Поиск видимой части меша
+   * необходимо это для того, чтобы отправлять только видимые элементы модели, а не все попадания
+   */
+  _getVisibleHit(e, t, s = 1e-4) {
+    return e ? t ? e.distance <= t.distance + s ? e : null : e : null;
   }
-  _handleTouchMoveRotate(e) {
-    if (this._pointers.length == 1)
-      this._rotateEnd.set(e.pageX, e.pageY);
-    else {
-      const i = this._getSecondPointerPosition(e), r = 0.5 * (e.pageX + i.x), o = 0.5 * (e.pageY + i.y);
-      this._rotateEnd.set(r, o);
-    }
-    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
-    const s = this.domElement;
-    this._rotateLeft(P * this._rotateDelta.x / s.clientHeight), this._rotateUp(P * this._rotateDelta.y / s.clientHeight), this._rotateStart.copy(this._rotateEnd);
-  }
-  _handleTouchMovePan(e) {
-    if (this._pointers.length === 1)
-      this._panEnd.set(e.pageX, e.pageY);
-    else {
-      const s = this._getSecondPointerPosition(e), i = 0.5 * (e.pageX + s.x), r = 0.5 * (e.pageY + s.y);
-      this._panEnd.set(i, r);
+  /** Строит ключ hover-пересечения с учетом текущего режима выборки */
+  _makeHoverKey(e) {
+    if (!e) return null;
+    const t = e.object.uuid;
+    switch (this._currentRaycastMode) {
+      case P.Face:
+        return `${t}:face:${e.faceIndex ?? -1}`;
+      case P.Edge:
+        return `${t}:edge:${Math.floor((e.index ?? -1) / 2)}`;
+      case P.Vertex:
+        return `${t}:vertex:${e.index ?? -1}`;
+      case P.Mesh:
+      default:
+        return `${t}:mesh`;
     }
-    this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd);
   }
-  _handleTouchMoveDolly(e) {
-    const s = this._getSecondPointerPosition(e), i = e.pageX - s.x, r = e.pageY - s.y, o = Math.sqrt(i * i + r * r);
-    this._dollyEnd.set(0, o), this._dollyDelta.set(0, Math.pow(this._dollyEnd.y / this._dollyStart.y, this.zoomSpeed)), this._dollyOut(this._dollyDelta.y), this._dollyStart.copy(this._dollyEnd);
-    const n = (e.pageX + s.x) * 0.5, h = (e.pageY + s.y) * 0.5;
-    this._updateZoomParameters(n, h);
+  /** Обработчик события для hover */
+  _handleMouseMove = (e) => {
+    this._processRaycastEvent(e, k.SelectHover, !0);
+  };
+  /** Обработчик события на click */
+  _handleMouseClick = (e) => {
+    this._processRaycastEvent(e, k.SelectClick, !1);
+  };
+  /** Обработчик двойного клика */
+  _handleDoubleClick = (e) => {
+    const t = this._getHitIntersection(e);
+    t !== void 0 && (t || this._bus.emit(k.SelectClick, null));
+  };
+  /** Обработчик ухода курсора с canvas */
+  _handleMouseLeave = () => {
+    this._lastHoverKey = null, this._bus.emit(k.SelectHover, null);
+  };
+  /** Инициализация обработчиков событий на hover/click */
+  _initMouseListeners() {
+    const e = this._domApi.getCanvas();
+    e.addEventListener("mousemove", this._handleMouseMove, !1), e.addEventListener("click", this._handleMouseClick, !1), e.addEventListener("dblclick", this._handleDoubleClick, !1), e.addEventListener("mouseleave", this._handleMouseLeave), this._isEventListenersAdded = !0;
   }
-  _handleTouchMoveDollyPan(e) {
-    this.enableZoom && this._handleTouchMoveDolly(e), this.enablePan && this._handleTouchMovePan(e);
+  _removeMouseListeners() {
+    const e = this._domApi.getCanvas();
+    e.removeEventListener("mousemove", this._handleMouseMove), e.removeEventListener("click", this._handleMouseClick), e.removeEventListener("dblclick", this._handleDoubleClick), e.removeEventListener("mouseleave", this._handleMouseLeave);
   }
-  _handleTouchMoveDollyRotate(e) {
-    this.enableZoom && this._handleTouchMoveDolly(e), this.enableRotate && this._handleTouchMoveRotate(e);
+  dispose() {
+    this._removeMouseListeners(), this._isEventListenersAdded = !1, this._lastHoverKey = null;
   }
-  // pointers
-  _addPointer(e) {
-    this._pointers.push(e.pointerId);
+};
+$e = tr([
+  w(),
+  q(0, _("IDomApi")),
+  q(1, _("ICameraApi")),
+  q(2, _("IMeshApi")),
+  q(3, _("IControlsStateApi")),
+  q(4, _("EventBus"))
+], $e);
+var sr = Object.getOwnPropertyDescriptor, rr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? sr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, ir = (e, t) => (s, r) => t(s, r, e);
+let Re = class {
+  constructor(e) {
+    this._api = e;
+  }
+  /** Объекты редактора, участвующие в raycast и редактировании */
+  _meshes = [];
+  /** Сетка сцены */
+  _grid = null;
+  /** Оси сцены */
+  _axes = null;
+  /** Базовый свет сцены */
+  _light = null;
+  init() {
+    this._grid = new l.GridHelper(10, 10), this._grid.position.y = -1e-3, this._api.addToScene(this._grid), this._axes = new is(6), this._api.addToScene(this._axes), this._light = new l.HemisphereLight(16777215, 4473924, 0.6), this._api.addToScene(this._light);
   }
-  _removePointer(e) {
-    delete this._pointerPositions[e.pointerId];
-    for (let s = 0; s < this._pointers.length; s++)
-      if (this._pointers[s] == e.pointerId) {
-        this._pointers.splice(s, 1);
-        return;
-      }
+  getMeshes() {
+    return this._meshes;
   }
-  _isTrackingPointer(e) {
-    for (let s = 0; s < this._pointers.length; s++)
-      if (this._pointers[s] == e.pointerId) return !0;
-    return !1;
+  addMesh(e) {
+    this._meshes.includes(e) || (this._meshes.push(e), this._api.addToScene(e));
   }
-  _trackPointer(e) {
-    let s = this._pointerPositions[e.pointerId];
-    s === void 0 && (s = new L(), this._pointerPositions[e.pointerId] = s), s.set(e.pageX, e.pageY);
+  removeMesh(e) {
+    const t = this._meshes.indexOf(e);
+    t >= 0 && this._meshes.splice(t, 1), this._api.removeFromScene(e);
   }
-  _getSecondPointerPosition(e) {
-    const s = e.pointerId === this._pointers[0] ? this._pointers[1] : this._pointers[0];
-    return this._pointerPositions[s];
+  addMeshes(e) {
+    for (const t of e)
+      this.addMesh(t);
   }
-  //
-  _customWheelEvent(e) {
-    const s = e.deltaMode, i = {
-      clientX: e.clientX,
-      clientY: e.clientY,
-      deltaY: e.deltaY
-    };
-    switch (s) {
-      case 1:
-        i.deltaY *= 16;
-        break;
-      case 2:
-        i.deltaY *= 100;
-        break;
-    }
-    return e.ctrlKey && !this._controlActive && (i.deltaY *= 10), i;
+  removeMeshes(e) {
+    for (const t of e)
+      this.removeMesh(t);
   }
-}
-function Et(t) {
-  this.enabled !== !1 && (this._pointers.length === 0 && (this.domElement.setPointerCapture(t.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.domElement.addEventListener("pointerup", this._onPointerUp)), !this._isTrackingPointer(t) && (this._addPointer(t), t.pointerType === "touch" ? this._onTouchStart(t) : this._onMouseDown(t)));
-}
-function xt(t) {
-  this.enabled !== !1 && (t.pointerType === "touch" ? this._onTouchMove(t) : this._onMouseMove(t));
-}
-function Pt(t) {
-  switch (this._removePointer(t), this._pointers.length) {
-    case 0:
-      this.domElement.releasePointerCapture(t.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.dispatchEvent(Be), this.state = p.NONE;
-      break;
-    case 1:
-      const e = this._pointers[0], s = this._pointerPositions[e];
-      this._onTouchStart({ pointerId: e, pageX: s.x, pageY: s.y });
-      break;
+  /** Освобождает ресурсы модуля */
+  dispose() {
+    for (const e of this._meshes)
+      this._api.removeFromScene(e);
+    this._meshes.length = 0, this._grid && (this._api.removeFromScene(this._grid), this._grid.geometry.dispose(), this._grid.material.dispose(), this._grid = null), this._axes && (this._api.removeFromScene(this._axes), this._axes = null), this._light && (this._api.removeFromScene(this._light), this._light = null);
   }
-}
-function Ot(t) {
-  let e;
-  switch (t.button) {
-    case 0:
-      e = this.mouseButtons.LEFT;
-      break;
-    case 1:
-      e = this.mouseButtons.MIDDLE;
-      break;
-    case 2:
-      e = this.mouseButtons.RIGHT;
-      break;
-    default:
-      e = -1;
-  }
-  switch (e) {
-    case Y.DOLLY:
-      if (this.enableZoom === !1) return;
-      this._handleMouseDownDolly(t), this.state = p.DOLLY;
-      break;
-    case Y.ROTATE:
-      if (t.ctrlKey || t.metaKey || t.shiftKey) {
-        if (this.enablePan === !1) return;
-        this._handleMouseDownPan(t), this.state = p.PAN;
-      } else {
-        if (this.enableRotate === !1) return;
-        this._handleMouseDownRotate(t), this.state = p.ROTATE;
-      }
-      break;
-    case Y.PAN:
-      if (t.ctrlKey || t.metaKey || t.shiftKey) {
-        if (this.enableRotate === !1) return;
-        this._handleMouseDownRotate(t), this.state = p.ROTATE;
-      } else {
-        if (this.enablePan === !1) return;
-        this._handleMouseDownPan(t), this.state = p.PAN;
-      }
-      break;
-    default:
-      this.state = p.NONE;
+};
+Re = rr([
+  w(),
+  ir(0, _("ISceneApi"))
+], Re);
+var nr = Object.getOwnPropertyDescriptor, or = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? nr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, ar = (e, t) => (s, r) => t(s, r, e);
+let Fe = class {
+  constructor(e) {
+    this._api = e;
   }
-  this.state !== p.NONE && this.dispatchEvent(be);
-}
-function Tt(t) {
-  switch (this.state) {
-    case p.ROTATE:
-      if (this.enableRotate === !1) return;
-      this._handleMouseMoveRotate(t);
-      break;
-    case p.DOLLY:
-      if (this.enableZoom === !1) return;
-      this._handleMouseMoveDolly(t);
-      break;
-    case p.PAN:
-      if (this.enablePan === !1) return;
-      this._handleMouseMovePan(t);
-      break;
+  /** Объекты вьювера */
+  _meshes = [];
+  /** Базовый свет сцены */
+  _light = null;
+  init() {
+    this._light = new l.HemisphereLight(16777215, 4473924, 0.6), this._api.addToScene(this._light);
   }
-}
-function Lt(t) {
-  this.enabled === !1 || this.enableZoom === !1 || this.state !== p.NONE || (t.preventDefault(), this.dispatchEvent(be), this._handleMouseWheel(this._customWheelEvent(t)), this.dispatchEvent(Be));
-}
-function Dt(t) {
-  this.enabled !== !1 && this._handleKeyDown(t);
-}
-function Ct(t) {
-  switch (this._trackPointer(t), this._pointers.length) {
-    case 1:
-      switch (this.touches.ONE) {
-        case z.ROTATE:
-          if (this.enableRotate === !1) return;
-          this._handleTouchStartRotate(t), this.state = p.TOUCH_ROTATE;
-          break;
-        case z.PAN:
-          if (this.enablePan === !1) return;
-          this._handleTouchStartPan(t), this.state = p.TOUCH_PAN;
-          break;
-        default:
-          this.state = p.NONE;
-      }
-      break;
-    case 2:
-      switch (this.touches.TWO) {
-        case z.DOLLY_PAN:
-          if (this.enableZoom === !1 && this.enablePan === !1) return;
-          this._handleTouchStartDollyPan(t), this.state = p.TOUCH_DOLLY_PAN;
-          break;
-        case z.DOLLY_ROTATE:
-          if (this.enableZoom === !1 && this.enableRotate === !1) return;
-          this._handleTouchStartDollyRotate(t), this.state = p.TOUCH_DOLLY_ROTATE;
-          break;
-        default:
-          this.state = p.NONE;
-      }
-      break;
-    default:
-      this.state = p.NONE;
+  getMeshes() {
+    return this._meshes;
   }
-  this.state !== p.NONE && this.dispatchEvent(be);
-}
-function At(t) {
-  switch (this._trackPointer(t), this.state) {
-    case p.TOUCH_ROTATE:
-      if (this.enableRotate === !1) return;
-      this._handleTouchMoveRotate(t), this.update();
-      break;
-    case p.TOUCH_PAN:
-      if (this.enablePan === !1) return;
-      this._handleTouchMovePan(t), this.update();
-      break;
-    case p.TOUCH_DOLLY_PAN:
-      if (this.enableZoom === !1 && this.enablePan === !1) return;
-      this._handleTouchMoveDollyPan(t), this.update();
-      break;
-    case p.TOUCH_DOLLY_ROTATE:
-      if (this.enableZoom === !1 && this.enableRotate === !1) return;
-      this._handleTouchMoveDollyRotate(t), this.update();
-      break;
-    default:
-      this.state = p.NONE;
+  addMesh(e) {
+    this._meshes.includes(e) || (this._meshes.push(e), this._api.addToScene(e));
   }
-}
-function It(t) {
-  this.enabled !== !1 && t.preventDefault();
-}
-function jt(t) {
-  t.key === "Control" && (this._controlActive = !0, this.domElement.getRootNode().addEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
-}
-function Rt(t) {
-  t.key === "Control" && (this._controlActive = !1, this.domElement.getRootNode().removeEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
-}
-class Ls extends Ne {
-  /** Orbit-контроллер для управления камерой */
-  _orbit;
-  constructor(e) {
-    super(e), this.camera.position.set(1, 1, 7), this.camera.lookAt(0, 0, 0), this._orbit = new St(this.camera, this.canvas), this._orbit.target.set(0, 0, 0), this._orbit.minPolarAngle = Math.PI / 2, this._orbit.maxPolarAngle = Math.PI / 2, this._orbit.enableRotate = !0, this._orbit.enableZoom = !1, this._orbit.enablePan = !1;
+  removeMesh(e) {
+    const t = this._meshes.indexOf(e);
+    t >= 0 && this._meshes.splice(t, 1), this._api.removeFromScene(e);
   }
-  /**
-   * Обновление состояния рендерера.
-   */
-  update() {
-    this._orbit?.update();
+  addMeshes(e) {
+    for (const t of e)
+      this.addMesh(t);
   }
-}
-class Ds {
-  /** Позиции вершин */
-  _positions = [];
-  /** Нормали вершин */
-  _normals = [];
-  /** UV-координаты (опционально) */
-  _uvs = [];
-  // Временные поля для парсинга файла
-  _tmpPositions = [];
-  _tmpNormals = [];
-  _tmpUVs = [];
-  /**
-   * Загружает OBJ-модель в Figure
-   * @param objContent - Строка содержимого .obj файла
-   */
-  load(e) {
-    const s = e.split(`
-`);
-    for (const r of s) {
-      if (!r.trim() || r.startsWith("#")) continue;
-      const o = r.trim().split(/\s+/);
-      switch (o[0]) {
-        case "v":
-          this._tmpPositions.push(o.slice(1).map(Number));
-          break;
-        case "vn":
-          this._tmpNormals.push(o.slice(1).map(Number));
-          break;
-        case "vt":
-          this._tmpUVs.push(o.slice(1).map(Number));
-          break;
-        case "f":
-          this.processFaceLine(o);
-          break;
-      }
-    }
-    const i = {
-      type: D.Custom,
-      position: this._positions,
-      ...this._normals.length > 0 && { normal: this._normals },
-      ...this._uvs.length > 0 && { uv: this._uvs }
-    };
-    return new et(i);
+  removeMeshes(e) {
+    for (const t of e)
+      this.removeMesh(t);
   }
-  /**
-   * Обрабатывает строку face (f) и разворачивает индексы в массивы для рендеринга
-   */
-  processFaceLine(e) {
-    for (let s = 1; s < e.length; s++) {
-      const i = e[s];
-      if (!i) continue;
-      const [r, o, n] = i.split("/"), h = r ? parseInt(r, 10) : void 0, l = o ? parseInt(o, 10) : void 0, c = n ? parseInt(n, 10) : void 0;
-      if (h !== void 0) {
-        const d = this._tmpPositions[h - 1];
-        d && this._positions.push(...d);
-      }
-      if (l !== void 0) {
-        const d = this._tmpUVs[l - 1];
-        d && this._uvs.push(...d);
-      }
-      if (c !== void 0) {
-        const d = this._tmpNormals[c - 1];
-        d && this._normals.push(...d);
-      }
-    }
+  /** Освобождает ресурсы модуля */
+  dispose() {
+    for (const e of this._meshes)
+      this._api.removeFromScene(e);
+    this._meshes.length = 0, this._light && (this._api.removeFromScene(this._light), this._light = null);
   }
-}
-var Vt = Object.getOwnPropertyDescriptor, kt = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? Vt(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, De = (t, e) => (s, i) => e(s, i, t);
-let te = class {
-  constructor(t, e) {
-    this._store = e, this._handlers = new Map(t.map((s) => [s.mode, s]));
+};
+Fe = or([
+  w(),
+  ar(0, _("ISceneApi"))
+], Fe);
+var E = /* @__PURE__ */ ((e) => (e[e.Display = 0] = "Display", e[e.Scene = 1] = "Scene", e[e.Select = 2] = "Select", e[e.Tool = 3] = "Tool", e))(E || {}), lr = Object.getOwnPropertyDescriptor, cr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? lr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, _t = (e, t) => (s, r) => t(s, r, e);
+let He = class {
+  constructor(e, t) {
+    this._store = t, this._handlers = new Map(e.map((s) => [s.mode, s]));
   }
   /** Текущий режим отображения */
-  _currentMode = $.Plane;
+  _currentMode = K.Plane;
   /** Хендлеры, которые управляют отображением */
   _handlers;
+  /** Тип фичи, за которую отвечает менеджер. */
+  type = E.Display;
   /** Установка режима отображения */
-  manage(t) {
-    t !== this._currentMode && (this._handlers.get(this._currentMode)?.rollback(), t !== $.Plane && this._handlers.get(t)?.handle(), this._currentMode = t, this._store.setDisplayMode(this._currentMode));
+  manage(e) {
+    e !== this._currentMode && (this._handlers.get(this._currentMode)?.rollback(), e !== K.Plane && this._handlers.get(e)?.handle(), this._currentMode = e, this._store.setDisplayMode(this._currentMode));
+  }
+  /** Освобождает ресурсы менеджера. */
+  dispose() {
+    this._handlers && this._handlers.clear(), this._currentMode = K.Plane, this._store.setDisplayMode(this._currentMode);
+  }
+};
+He = cr([
+  w(),
+  _t(0, B("IDisplayHandler")),
+  _t(1, _("EditorStore"))
+], He);
+var hr = Object.getOwnPropertyDescriptor, dr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? hr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, ur = (e, t) => (s, r) => t(s, r, e);
+let pe = class {
+  /** Текущий режим редактирования сцены */
+  _currentMode = T.AddFigure;
+  /** Хендлеры, которые управляют отображением */
+  _handlers;
+  /** Тип фичи, за которую отвечает менеджер. */
+  type = E.Scene;
+  constructor(e) {
+    this._handlers = new Map(e.map((t) => [t.mode, t]));
+  }
+  /** Установка режима редактирования сцены */
+  manage(e, t) {
+    this._handlers.get(e)?.handle(t), this._currentMode = e;
   }
   /** Освобождает ресурсы менеджера. */
   dispose() {
-    this._handlers && this._handlers.clear(), this._currentMode = $.Plane, this._store.setDisplayMode(this._currentMode);
+    this._handlers && this._handlers.clear(), this._currentMode = T.AddFigure;
   }
 };
-te = kt([
-  M(),
-  De(0, G("IDisplayHandler")),
-  De(1, _("IEditorStore"))
-], te);
-var C = /* @__PURE__ */ ((t) => (t.Hover = "hover", t.Click = "click", t))(C || {}), Ht = Object.getOwnPropertyDescriptor, Ft = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? Ht(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, q = (t, e) => (s, i) => e(s, i, t);
-let se = class {
-  constructor(t, e, s) {
-    this._eventBus = t, this._store = s, this._handlers = new Map(e.map((i) => [i.mode, i])), this._eventBus.on(H.SelectHover, this._onHover), this._eventBus.on(H.SelectClick, this._onClick);
+pe = dr([
+  w(),
+  ur(0, B("ISceneHandler"))
+], pe);
+var F = /* @__PURE__ */ ((e) => (e.Hover = "hover", e.Click = "click", e))(F || {}), _r = Object.getOwnPropertyDescriptor, pr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? _r(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Ie = (e, t) => (s, r) => t(s, r, e);
+let Be = class {
+  constructor(e, t, s) {
+    this._eventBus = e, this._store = s, this._handlers = new Map(t.map((r) => [r.mode, r])), this._eventBus.on(k.SelectHover, this._onHover), this._eventBus.on(k.SelectClick, this._onClick);
   }
   /** Текущий режим выборки */
-  _currentMode = y.Mesh;
+  _currentMode = P.Mesh;
   /** Хендлеры, которые управляют выборкой */
   _handlers;
+  /** Тип фичи, за которую отвечает менеджер. */
+  type = E.Select;
   /** Переключает режим выбора */
-  manage(t) {
-    t !== this._currentMode && (this._handlers.get(this._currentMode)?.rollback(), this._currentMode = t, this._store.setSelectMode(this._currentMode));
+  manage(e) {
+    e !== this._currentMode && (this._handlers.get(this._currentMode)?.rollback(), this._currentMode = e, this._store.setSelectMode(this._currentMode));
   }
   /** Обработчик события наведения на модель */
-  _onHover = (t) => {
-    this._handlers.get(this._currentMode)?.handle(t, C.Hover);
+  _onHover = (e) => {
+    this._handlers.get(this._currentMode)?.handle(e, F.Hover);
   };
   /** Обработчик события клика на модель */
-  _onClick = (t) => {
-    this._handlers.get(this._currentMode)?.handle(t, C.Click);
+  _onClick = (e) => {
+    this._handlers.get(this._currentMode)?.handle(e, F.Click);
   };
   /** Освобождает ресурсы менеджера. */
   dispose() {
-    this._handlers && this._handlers.clear(), this._eventBus.off(H.SelectHover, this._onHover), this._currentMode = y.Mesh, this._store.setSelectMode(this._currentMode);
+    this._handlers && this._handlers.clear(), this._eventBus.off(k.SelectHover, this._onHover), this._currentMode = P.Mesh, this._store.setSelectMode(this._currentMode);
   }
 };
-se = Ft([
-  M(),
-  q(0, _("EventBus")),
-  q(1, G("ISelectHandler")),
-  q(2, _("IEditorStore"))
-], se);
-class Wt {
-  /** Доступен ли инструмент при текущем режиме выборки */
-  isToolEnabled(e, s) {
-    return Pe[s].includes(e);
-  }
-  /** Получение доступных инструментов для режима выборки*/
-  getEnabledTools(e) {
-    return Pe[e];
-  }
-}
-var zt = Object.getOwnPropertyDescriptor, Nt = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? zt(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Ce = (t, e) => (s, i) => e(s, i, t);
-let ie = class {
-  constructor(t, e) {
-    this._store = e, this._handlers = new Map(t.map((s) => [s.mode, s])), this._unsubSelected = this._store.onSelectedObjectChange(() => {
+Be = pr([
+  w(),
+  Ie(0, _("EventBus")),
+  Ie(1, B("ISelectHandler")),
+  Ie(2, _("EditorStore"))
+], Be);
+const mr = (e) => (t, s, r) => {
+  const i = r.value;
+  if (!i)
+    throw new Error("usePolicy can only be applied to method");
+  return r.value = function(...n) {
+    return e(this).check(...n), i.apply(this, n);
+  }, r;
+}, $t = (e) => (t, s, r) => {
+  const i = r.value;
+  if (!i)
+    throw new Error("useValidator can only be applied to method");
+  return r.value = function(...n) {
+    return e(this).validate(...n), i.apply(this, n);
+  }, r;
+};
+var gr = Object.defineProperty, fr = Object.getOwnPropertyDescriptor, Rt = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? fr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = (r ? o(t, s, i) : o(i)) || i);
+  return r && i && gr(t, s, i), i;
+}, Pe = (e, t) => (s, r) => t(s, r, e);
+let me = class {
+  constructor(e, t, s) {
+    this._store = t, this._policy = s, this._handlers = new Map(e.map((r) => [r.mode, r])), this._unsubSelected = this._store.onSelectedObjectChange(() => {
       this._handlers.get(this._currentTool)?.handle();
-    }), this._policy = new Wt();
+    });
   }
   /** Текущий выбранный инструмент */
-  _currentTool = F.Translate;
+  _currentTool = U.Translate;
   /** Хендлеры, которые управляют инструментами */
   _handlers;
   /** Событие обновления выбора объекта */
   _unsubSelected;
-  /** Политика доступности инструментов */
-  _policy;
-  manage(t) {
-    if (this._currentTool === t) return;
-    const e = this._store.getSelectMode();
-    this._policy.isToolEnabled(t, e) && (this._handlers.get(this._currentTool)?.rollback(), this._currentTool = t, this._store.setToolType(this._currentTool), this._handlers.get(this._currentTool)?.handle());
-  }
-  /** Освобождает ресурсы менеджера. */
-  dispose() {
-    this._unsubSelected?.(), this._handlers && this._handlers.clear(), this._currentTool = F.Translate, this._store.setToolType(this._currentTool);
-  }
-};
-ie = Nt([
-  M(),
-  Ce(0, G("IToolHandler")),
-  Ce(1, _("IEditorStore"))
-], ie);
-var Yt = Object.getOwnPropertyDescriptor, $t = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? Yt(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Ut = (t, e) => (s, i) => e(s, i, t);
-let re = class {
-  /** Текущий режим редактирования сцены */
-  _currentMode = U.AddFigure;
-  /** Хендлеры, которые управляют отображением */
-  _handlers;
-  constructor(t) {
-    this._handlers = new Map(t.map((e) => [e.mode, e]));
-  }
-  /** Установка режима редактирования сцены */
-  manage(t, e) {
-    t === U.AddFigure ? this._handlers.get(t)?.handle(e) : this._handlers.get(t)?.handle(), this._currentMode = t;
+  /** Тип фичи, за которую отвечает менеджер. */
+  type = E.Tool;
+  manage(e) {
+    this._currentTool !== e && (this._handlers.get(this._currentTool)?.rollback(), this._currentTool = e, this._store.setToolType(this._currentTool), this._handlers.get(this._currentTool)?.handle());
   }
   /** Освобождает ресурсы менеджера. */
   dispose() {
-    this._handlers && this._handlers.clear(), this._currentMode = U.AddFigure;
+    this._unsubSelected?.(), this._handlers && this._handlers.clear(), this._currentTool = U.Translate, this._store.setToolType(this._currentTool);
   }
 };
-re = $t([
-  M(),
-  Ut(0, G("ISceneHandler"))
-], re);
-var Bt = Object.getOwnPropertyDescriptor, Gt = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? Bt(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Zt = (t, e) => (s, i) => e(s, i, t);
-let oe = class {
-  constructor(t) {
-    this._api = t;
+Rt([
+  mr((e) => e._policy)
+], me.prototype, "manage", 1);
+me = Rt([
+  w(),
+  Pe(0, B("IToolHandler")),
+  Pe(1, _("EditorStore")),
+  Pe(2, _("ToolPolicy"))
+], me);
+var vr = Object.getOwnPropertyDescriptor, yr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? vr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, br = (e, t) => (s, r) => t(s, r, e);
+let ke = class {
+  constructor(e) {
+    this._api = e;
   }
   /** Режим отображения. */
-  mode = $.Wireframe;
+  mode = K.Wireframe;
   /** Сохраняем предыдущие значения wireframe для отката. */
   _prevWireframe = /* @__PURE__ */ new Map();
   /** Сохраняем исходные цвета материалов для отката */
   _prevColorMesh = /* @__PURE__ */ new Map();
   _prevColorLines = /* @__PURE__ */ new Map();
   /** Цвет ребер для wireframe-режима. */
-  _wireColor = new a.Color(65535);
+  _wireColor = new l.Color(65535);
   /** Применяет wireframe-режим к сцене. */
   handle() {
-    const t = this._api.getMeshes();
-    for (const e of t) {
-      const s = Array.isArray(e.material) ? e.material : [e.material];
-      for (const i of s) this._enableWireframeOnMaterial(i);
-      e.traverse((i) => {
-        if (i.isLineSegments) {
-          const r = i;
-          if (!this._prevColorLines.has(r.material)) {
-            const n = r.material;
-            this._prevColorLines.set(n, n.color.clone());
+    const e = this._api.getMeshes();
+    for (const t of e) {
+      const s = Array.isArray(t.material) ? t.material : [t.material];
+      for (const r of s) this._enableWireframeOnMaterial(r);
+      t.traverse((r) => {
+        if (r.isLineSegments) {
+          const i = r;
+          if (!this._prevColorLines.has(i.material)) {
+            const o = i.material;
+            this._prevColorLines.set(o, o.color.clone());
           }
-          const o = r.material;
-          o.color.copy(this._wireColor), o.needsUpdate = !0;
+          const n = i.material;
+          n.color.copy(this._wireColor), n.needsUpdate = !0;
         }
       });
     }
   }
   /** Отключает wireframe-режим и возвращает оригинальные меши. */
   rollback() {
-    for (const [t, e] of this._prevWireframe)
-      "wireframe" in t && (t.wireframe = e), t.needsUpdate = !0;
+    for (const [e, t] of this._prevWireframe)
+      "wireframe" in e && (e.wireframe = t), e.needsUpdate = !0;
     this._prevWireframe.clear();
-    for (const [t, e] of this._prevColorMesh) {
-      const s = t;
-      s.color?.isColor && s.color.copy(e);
+    for (const [e, t] of this._prevColorMesh) {
+      const s = e;
+      s.color?.isColor && s.color.copy(t);
     }
     this._prevColorMesh.clear();
-    for (const [t, e] of this._prevColorLines)
-      t.color.copy(e);
+    for (const [e, t] of this._prevColorLines)
+      e.color.copy(t);
     this._prevColorLines.clear();
   }
   /** Освобождает ресурсы хендлера, удаляет слушатели и очищает внутренние данные. */
@@ -1143,107 +1748,161 @@ let oe = class {
     this.rollback();
   }
   /** Изменить цвет, который будет применяться в режиме wireframe. */
-  _enableWireframeOnMaterial(t) {
-    const e = t;
-    "wireframe" in e && !this._prevWireframe.has(t) && (this._prevWireframe.set(t, !!e.wireframe), e.wireframe = !0, t.needsUpdate = !0), e.color?.isColor && (this._prevColorMesh.has(t) || this._prevColorMesh.set(t, e.color.clone()), e.color.copy(this._wireColor));
+  _enableWireframeOnMaterial(e) {
+    const t = e;
+    "wireframe" in t && !this._prevWireframe.has(e) && (this._prevWireframe.set(e, !!t.wireframe), t.wireframe = !0, e.needsUpdate = !0), t.color?.isColor && (this._prevColorMesh.has(e) || this._prevColorMesh.set(e, t.color.clone()), t.color.copy(this._wireColor));
   }
 };
-oe = Gt([
-  M(),
-  Zt(0, _("RendererApi"))
-], oe);
-var Xt = Object.getOwnPropertyDescriptor, Kt = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? Xt(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Ae = (t, e) => (s, i) => e(s, i, t);
-let ne = class {
-  constructor(t, e) {
-    this._api = t, this._store = e;
+ke = yr([
+  w(),
+  br(0, _("IMeshApi"))
+], ke);
+var Mr = Object.getOwnPropertyDescriptor, xr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Mr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, re = (e, t) => (s, r) => t(s, r, e);
+let ze = class {
+  constructor(e, t, s, r) {
+    this._sceneApi = e, this._cameraApi = t, this._raycastApi = s, this._store = r, this._cameraApi.enableCameraLayer($), this._hoverLine = Y(this._makeOverlayLine(this._hoverColor)), this._selectLine = Y(this._makeOverlayLine(this._selectColor)), this._sceneApi.addObject(this._hoverLine, $), this._sceneApi.addObject(this._selectLine, $);
   }
   /** Режим, которым управляет хендлер, нужен только менеджеру */
-  mode = y.Mesh;
-  /** Фигура, на которую навелись в данный момент */
-  _hoveredMesh = null;
-  /** Фигура, которую выбрали в данный момент */
-  _selectedMesh = null;
+  mode = P.Edge;
+  /** Текущее наведённое ребро. */
+  _hoverLine;
+  /** Текущее выбранное ребро. */
+  _selectLine;
+  /** Текущее наведённое ребро из массива `LineSegments` модели. */
+  _hovered = null;
+  /** Текущее выбранное ребро из массива `LineSegments` модели. */
+  _selected = null;
   // Цвета, необходимые для переключения
-  /** Цвет ребер для фигуры, на которую навелись */
-  _hoverColor = Z;
-  /** Цвет ребер для выделенной фигуры */
-  _selectColor = X;
-  /** Исходные цвета материалов линий для отката */
-  _origLineColors = /* @__PURE__ */ new WeakMap();
-  handle(t, e) {
-    if (this._api.setRaycastMode(this.mode), e === C.Hover) {
-      if (!t) {
-        this._hoveredMesh && this._hoveredMesh !== this._selectedMesh && this._restoreEdgesColor(this._hoveredMesh), this._hoveredMesh = null;
+  /** Цвет ребра, на которое навелись */
+  _hoverColor = Me;
+  /** Цвет выделенного ребра */
+  _selectColor = xe;
+  /** Обработка текущего режима выборки. */
+  handle(e, t) {
+    if (this._raycastApi.setRaycastMode(this.mode), t === F.Hover) {
+      if (!e) {
+        this._hoverLine.visible = !1, this._hovered = null;
         return;
       }
-      const s = t.intersection.object;
-      this._hoveredMesh !== s && (this._hoveredMesh && this._hoveredMesh !== this._selectedMesh && this._restoreEdgesColor(this._hoveredMesh), s !== this._selectedMesh && this._paintEdges(s, this._hoverColor), this._hoveredMesh = s);
+      const s = e.intersection.object;
+      if (!s?.isLineSegments) return;
+      const r = s, i = Math.floor((e.intersection.index ?? -1) / 2);
+      if (i < 0) return;
+      this._selected && this._same({ lines: r, seg: i }, this._selected) ? this._hoverLine.visible = !1 : (this._writeWorldSegment(this._hoverLine, r, i), this._hoverLine.visible = !0), this._hovered = { lines: r, seg: i };
+      return;
     }
-    if (e === C.Click) {
-      if (!t) {
-        this._selectedMesh && (this._restoreEdgesColor(this._selectedMesh), this._selectedMesh = null, this._store.setSelectedObject(null));
+    if (t === F.Click) {
+      if (!e) {
+        this._selectLine.visible = !1, this._selected = null, this._store.setSelectedObject(null);
         return;
       }
-      const s = t.intersection.object;
-      this._selectedMesh && this._selectedMesh !== s && this._restoreEdgesColor(this._selectedMesh), this._paintEdges(s, this._selectColor), this._selectedMesh = s, this._store.setSelectedObject(s);
+      const s = e.intersection.object;
+      if (!s?.isLineSegments) return;
+      const r = s, i = Math.floor((e.intersection.index ?? -1) / 2);
+      if (i < 0) return;
+      this._writeWorldSegment(this._selectLine, r, i), this._centerAndOrientLineOnSegment(this._selectLine, r, i), this._selectLine.visible = !0, this._prepareEdgeMetadata(r, i), this._store.setSelectedObject(this._selectLine), this._selected = { lines: r, seg: i }, this._hovered && this._same(this._hovered, this._selected) && (this._hoverLine.visible = !1);
     }
   }
+  /** Откат текущего режима выборки */
   rollback() {
-    this._hoveredMesh && this._restoreEdgesColor(this._hoveredMesh), this._selectedMesh && this._restoreEdgesColor(this._selectedMesh), this._hoveredMesh = this._selectedMesh = null, this._store.setSelectedObject(null);
+    this._hoverLine.visible = !1, this._selectLine.visible = !1, this._hovered = this._selected = null, this._store.setSelectedObject(null);
   }
   /** Освобождает ресурсы хендлера, удаляет слушатели и очищает внутренние данные. */
   dispose() {
-    this.rollback();
+    this.rollback(), this._sceneApi.removeFromScene(this._hoverLine), this._sceneApi.removeFromScene(this._selectLine), this._hoverLine.geometry.dispose(), this._hoverLine.material.dispose(), this._selectLine.geometry.dispose(), this._selectLine.material.dispose();
   }
-  /**
-   * Перекрасить рёбра меша и запомнить оригинальный цвет (один раз на LineSegments).
+  /** Инициализация буферных линий для режима (hover и click).
+   * На весь режим будет использовано 2 глобальных линии на сцене,
+   * использоваться они будут только для обозначения геометрии ребер конкретной фигуры.
    */
-  _paintEdges(t, e) {
-    t.children.forEach((s) => {
-      const i = s;
-      if (i.isLineSegments && i.material) {
-        const r = i.material;
-        this._origLineColors.has(i) || this._origLineColors.set(i, r.color.clone()), r.color.setHex(e), r.needsUpdate = !0;
-      }
-    });
+  _makeOverlayLine(e) {
+    const t = new l.BufferGeometry();
+    t.setAttribute("position", new l.Float32BufferAttribute(6, 3));
+    const s = new l.LineBasicMaterial({
+      color: e,
+      depthTest: !1,
+      depthWrite: !1,
+      transparent: !0,
+      opacity: 1
+    }), r = new l.Line(t, s);
+    return r.renderOrder = 1e3, r.raycast = () => {
+    }, r.layers.set($), r.visible = !1, r;
   }
-  /**
-   * Восстановить исходный цвет рёбер меша из WeakMap.
-   * Если исходный цвет не сохранён (на всякий случай) — ничего не меняем.
-   */
-  _restoreEdgesColor(t) {
-    t.children.forEach((e) => {
-      const s = e;
-      if (s.isLineSegments && s.material) {
-        const i = this._origLineColors.get(s);
-        if (i) {
-          const r = s.material;
-          r.color.copy(i), r.needsUpdate = !0;
-        }
-      }
-    });
+  /** Локальные точки сегмента переводим в target (который висит на сцене) */
+  _writeWorldSegment(e, t, s) {
+    const r = t.geometry.getAttribute("position"), i = s * 2, n = i + 1, o = new l.Vector3(r.getX(i), r.getY(i), r.getZ(i)).applyMatrix4(
+      t.matrixWorld
+    ), c = new l.Vector3(r.getX(n), r.getY(n), r.getZ(n)).applyMatrix4(
+      t.matrixWorld
+    ), u = e.geometry.getAttribute("position");
+    u.setXYZ(0, o.x, o.y, o.z), u.setXYZ(1, c.x, c.y, c.z), u.needsUpdate = !0;
+  }
+  _same(e, t) {
+    return !!e && !!t && e.lines === t.lines && e.seg === t.seg;
+  }
+  /** Центрует `THREE.Line` на сегменте и ориентирует её вдоль ребра */
+  _centerAndOrientLineOnSegment(e, t, s) {
+    const r = t.geometry.getAttribute("position"), i = s * 2, n = i + 1, o = new l.Vector3(r.getX(i), r.getY(i), r.getZ(i)).applyMatrix4(
+      t.matrixWorld
+    ), c = new l.Vector3(r.getX(n), r.getY(n), r.getZ(n)).applyMatrix4(
+      t.matrixWorld
+    ), u = new l.Vector3().subVectors(c, o), d = u.length();
+    if (!isFinite(d) || d === 0) return;
+    const m = new l.Vector3().addVectors(o, c).multiplyScalar(0.5);
+    e.position.copy(m);
+    const p = e.geometry;
+    let g = p.getAttribute("position");
+    (!g || g.count < 2) && (p.setAttribute("position", new l.BufferAttribute(new Float32Array(6), 3)), g = p.getAttribute("position")), g.setXYZ(0, -d / 2, 0, 0), g.setXYZ(1, d / 2, 0, 0), g.needsUpdate = !0, u.normalize();
+    const f = new l.Quaternion().setFromUnitVectors(new l.Vector3(1, 0, 0), u);
+    e.quaternion.copy(f), e.updateMatrixWorld(!0);
+  }
+  /** Запись метаданных выбранного ребра для использования инструментов */
+  _prepareEdgeMetadata(e, t) {
+    const s = Pt(e);
+    if (!s) return;
+    const r = e.geometry.getAttribute("position"), i = t * 2, n = i + 1, o = new l.Vector3(r.getX(i), r.getY(i), r.getZ(i)).applyMatrix4(
+      e.matrixWorld
+    ), c = new l.Vector3(r.getX(n), r.getY(n), r.getZ(n)).applyMatrix4(
+      e.matrixWorld
+    ), u = new l.Matrix4().copy(s.matrixWorld).invert(), d = o.clone().applyMatrix4(u), m = c.clone().applyMatrix4(u), g = s.geometry.getAttribute("position"), f = new l.Vector3(), h = 1e-6, v = [], y = [];
+    for (let O = 0; O < g.count; O++)
+      f.fromBufferAttribute(g, O), f.distanceToSquared(d) < h * h ? v.push(O) : f.distanceToSquared(m) < h * h && y.push(O);
+    const A = new l.Matrix4().copy(e.matrixWorld).invert(), S = o.clone().applyMatrix4(A), x = c.clone().applyMatrix4(A), b = e.geometry.getAttribute("position"), C = new l.Vector3(), M = [], I = [];
+    for (let O = 0; O < b.count; O++)
+      C.fromBufferAttribute(b, O), C.distanceToSquared(S) < h * h ? M.push(O) : C.distanceToSquared(x) < h * h && I.push(O);
+    this._selectLine.userData.edgeInfo = {
+      lines: e,
+      seg: t,
+      mesh: s,
+      aIndices: v,
+      bIndices: y,
+      aEdgeIndices: M,
+      bEdgeIndices: I
+    };
   }
 };
-ne = Kt([
-  M(),
-  Ae(0, _("RendererApi")),
-  Ae(1, _("IEditorStore"))
-], ne);
-var qt = Object.getOwnPropertyDescriptor, Qt = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? qt(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Ie = (t, e) => (s, i) => e(s, i, t);
-let ae = class {
-  constructor(t, e) {
-    this._api = t, this._store = e, this._api.enableCameraLayer(T), this._hoverFace = this._makeOverlayFace(this._hoverColor), this._selectFace = this._makeOverlayFace(this._selectColor), this._api.addObject(this._hoverFace, T), this._api.addObject(this._selectFace, T);
+ze = xr([
+  w(),
+  re(0, _("ISceneApi")),
+  re(1, _("ICameraApi")),
+  re(2, _("IRaycastApi")),
+  re(3, _("EditorStore"))
+], ze);
+var Sr = Object.getOwnPropertyDescriptor, wr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Sr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, ie = (e, t) => (s, r) => t(s, r, e);
+let Ge = class {
+  constructor(e, t, s, r) {
+    this._cameraApi = e, this._sceneApi = t, this._raycastApi = s, this._store = r, this._cameraApi.enableCameraLayer($), this._hoverFace = Y(this._makeOverlayFace(this._hoverColor)), this._selectFace = Y(this._makeOverlayFace(this._selectColor)), this._sceneApi.addObject(this._hoverFace, $), this._sceneApi.addObject(this._selectFace, $);
   }
   /** Режим, которым управляет хендлер, нужен только менеджеру */
-  mode = y.Face;
+  mode = P.Face;
   /** Текущая наведённая грань */
   _hoverFace;
   /** Текущая выбранная грань */
@@ -1258,42 +1917,42 @@ let ae = class {
   _selected = null;
   // Цвета, необходимые для переключения
   /** Цвет грани, на которую навелись */
-  _hoverColor = Z;
+  _hoverColor = Me;
   /** Цвет выделенной граней */
-  _selectColor = X;
+  _selectColor = xe;
   // Погрешности для поиска треугольников и сборки граней
   /** Погрешность на сравнение нормалей */
   _normalEps = 1e-4;
   /** Погрешность на принадлежность одной плоскости */
   _planeEps = 1e-4;
   /** Обработка текущего режима выборки. */
-  handle(t, e) {
-    if (this._api.setRaycastMode(this.mode), e === C.Hover) {
-      if (!t) {
+  handle(e, t) {
+    if (this._raycastApi.setRaycastMode(this.mode), t === F.Hover) {
+      if (!e) {
         this._hoverFace.visible = !1, this._hovered = null;
         return;
       }
-      const s = t.intersection.object;
+      const s = e.intersection.object;
       if (!s?.isMesh) return;
-      const i = s, r = t.intersection.faceIndex ?? -1;
-      if (r < 0) return;
-      const o = this._collectFaceGroup(i, r);
-      if (!o) return;
-      this._selected && this._same(o, this._selected) ? this._hoverFace.visible = !1 : (this._writeWorldFaceGroup(this._hoverFace, o), this._hoverFace.visible = !0), this._hovered = o;
+      const r = s, i = e.intersection.faceIndex ?? -1;
+      if (i < 0) return;
+      const n = this._collectFaceGroup(r, i);
+      if (!n) return;
+      this._selected && this._same(n, this._selected) ? this._hoverFace.visible = !1 : (this._writeWorldFaceGroup(this._hoverFace, n), this._hoverFace.visible = !0), this._hovered = n;
       return;
     }
-    if (e === C.Click) {
-      if (!t) {
+    if (t === F.Click) {
+      if (!e) {
         this._selectFace.visible = !1, this._selected = null, this._store.setSelectedObject(null);
         return;
       }
-      const s = t.intersection.object;
+      const s = e.intersection.object;
       if (!s?.isMesh) return;
-      const i = s, r = t.intersection.faceIndex ?? -1;
-      if (r < 0) return;
-      const o = this._collectFaceGroup(i, r);
-      if (!o) return;
-      this._writeWorldFaceGroup(this._selectFace, o), this._centerFaceProxy(this._selectFace), this._selectFace.visible = !0, this._prepareFaceMetadata(o), this._store.setSelectedObject(this._selectFace), this._selected = o, this._hovered && this._same(this._hovered, this._selected) && (this._hoverFace.visible = !1);
+      const r = s, i = e.intersection.faceIndex ?? -1;
+      if (i < 0) return;
+      const n = this._collectFaceGroup(r, i);
+      if (!n) return;
+      this._writeWorldFaceGroup(this._selectFace, n), this._centerFaceProxy(this._selectFace), this._selectFace.visible = !0, this._prepareFaceMetadata(n), this._store.setSelectedObject(this._selectFace), this._selected = n, this._hovered && this._same(this._hovered, this._selected) && (this._hoverFace.visible = !1);
     }
   }
   /** Откат текущего режима выборки */
@@ -1302,235 +1961,318 @@ let ae = class {
   }
   /** Освобождает ресурсы хендлера, удаляет слушатели и очищает внутренние данные. */
   dispose() {
-    this.rollback(), this._api.removeObject(this._hoverFace), this._api.removeObject(this._selectFace), this._hoverFace.geometry.dispose(), this._hoverFace.material.dispose(), this._selectFace.geometry.dispose(), this._selectFace.material.dispose();
+    this.rollback(), this._sceneApi.removeFromScene(this._hoverFace), this._sceneApi.removeFromScene(this._selectFace), this._hoverFace.geometry.dispose(), this._hoverFace.material.dispose(), this._selectFace.geometry.dispose(), this._selectFace.material.dispose();
   }
   /**
    * Инициализация overlay mesh для режима (hover и click).
    * На весь режим используются 2 глобальных mesh на сцене,
    * геометрия которых переписывается под текущую грань.
    */
-  _makeOverlayFace(t) {
-    const e = new a.BufferGeometry(), s = new a.MeshBasicMaterial({
-      color: t,
+  _makeOverlayFace(e) {
+    const t = new l.BufferGeometry(), s = new l.MeshBasicMaterial({
+      color: e,
       transparent: !0,
       opacity: 0.35,
       depthTest: !1,
       depthWrite: !1,
-      side: a.DoubleSide,
+      side: l.DoubleSide,
       polygonOffset: !0,
       polygonOffsetFactor: -1,
       polygonOffsetUnits: -1
-    }), i = new a.Mesh(e, s);
-    return i.renderOrder = 1e3, i.layers.set(T), i.visible = !1, i.raycast = () => {
-    }, i;
+    }), r = new l.Mesh(t, s);
+    return r.renderOrder = 1e3, r.layers.set($), r.visible = !1, r.raycast = () => {
+    }, r;
   }
   /**
    * Сбор логической грани как связной группы компланарных треугольников.
    * Если geometry неиндексированная — пока возвращаем только стартовый triangle.
    */
-  _collectFaceGroup(t, e) {
-    const s = t.geometry, i = s.getAttribute("position");
-    if (!i) return null;
-    const r = s.index;
-    if (!r) {
-      const E = e * 3, O = e * 3 + 1, A = e * 3 + 2;
+  _collectFaceGroup(e, t) {
+    const s = e.geometry, r = s.getAttribute("position");
+    if (!r) return null;
+    const i = s.index;
+    if (!i) {
+      const b = t * 3, C = t * 3 + 1, M = t * 3 + 2;
       return {
-        mesh: t,
-        faceIndex: e,
-        triangleIndices: [e],
-        vertexIndices: [E, O, A],
-        proxyVertexMap: [E, O, A]
+        mesh: e,
+        faceIndex: t,
+        triangleIndices: [t],
+        vertexIndices: [b, C, M],
+        proxyVertexMap: [b, C, M]
       };
     }
-    const o = Math.floor(r.count / 3);
-    if (e < 0 || e >= o) return null;
-    const n = this._buildTriangleAdjacency(r, i), [h, l, c] = this._getTriangleIndices(r, e), d = this._readVertex(i, h), g = this._readVertex(i, l), m = this._readVertex(i, c), f = new a.Vector3().subVectors(g, d).cross(new a.Vector3().subVectors(m, d)).normalize(), u = new a.Plane().setFromNormalAndCoplanarPoint(f, d), w = /* @__PURE__ */ new Set(), S = [], j = [e];
-    for (; j.length > 0; ) {
-      const E = j.pop();
-      if (w.has(E)) continue;
-      w.add(E);
-      const [O, A, k] = this._getTriangleIndices(r, E), x = this._readVertex(i, O), ye = this._readVertex(i, A), Me = this._readVertex(i, k), Ge = new a.Vector3().subVectors(ye, x).cross(new a.Vector3().subVectors(Me, x)).normalize(), Ze = Math.abs(Ge.dot(f)) >= 1 - this._normalEps, Xe = Math.abs(u.distanceToPoint(x)) < this._planeEps && Math.abs(u.distanceToPoint(ye)) < this._planeEps && Math.abs(u.distanceToPoint(Me)) < this._planeEps;
-      if (!Ze || !Xe) continue;
-      S.push(E);
-      const we = n.get(E);
-      if (we)
-        for (const Se of we)
-          w.has(Se) || j.push(Se);
+    const n = Math.floor(i.count / 3);
+    if (t < 0 || t >= n) return null;
+    const o = this._buildTriangleAdjacency(i, r), [c, u, d] = this._getTriangleIndices(i, t), m = this._readVertex(r, c), p = this._readVertex(r, u), g = this._readVertex(r, d), f = new l.Vector3().subVectors(p, m).cross(new l.Vector3().subVectors(g, m)).normalize(), h = new l.Plane().setFromNormalAndCoplanarPoint(f, m), v = /* @__PURE__ */ new Set(), y = [], A = [t];
+    for (; A.length > 0; ) {
+      const b = A.pop();
+      if (v.has(b)) continue;
+      v.add(b);
+      const [C, M, I] = this._getTriangleIndices(i, b), O = this._readVertex(r, C), V = this._readVertex(r, M), D = this._readVertex(r, I), H = new l.Vector3().subVectors(V, O).cross(new l.Vector3().subVectors(D, O)).normalize(), Gt = Math.abs(H.dot(f)) >= 1 - this._normalEps, Wt = Math.abs(h.distanceToPoint(O)) < this._planeEps && Math.abs(h.distanceToPoint(V)) < this._planeEps && Math.abs(h.distanceToPoint(D)) < this._planeEps;
+      if (!Gt || !Wt) continue;
+      y.push(b);
+      const st = o.get(b);
+      if (st)
+        for (const rt of st)
+          v.has(rt) || A.push(rt);
     }
-    S.sort((E, O) => E - O);
-    const R = /* @__PURE__ */ new Set(), V = [];
-    for (const E of S) {
-      const [O, A, k] = this._getTriangleIndices(r, E);
-      R.add(O), R.add(A), R.add(k), V.push(O, A, k);
+    y.sort((b, C) => b - C);
+    const S = /* @__PURE__ */ new Set(), x = [];
+    for (const b of y) {
+      const [C, M, I] = this._getTriangleIndices(i, b);
+      S.add(C), S.add(M), S.add(I), x.push(C, M, I);
     }
     return {
-      mesh: t,
-      faceIndex: e,
-      triangleIndices: S,
-      vertexIndices: Array.from(R),
-      proxyVertexMap: V
+      mesh: e,
+      faceIndex: t,
+      triangleIndices: y,
+      vertexIndices: Array.from(S),
+      proxyVertexMap: x
     };
   }
   /** Перезаписывает overlay mesh world-space треугольниками выбранной грани */
-  _writeWorldFaceGroup(t, e) {
-    const s = e.mesh.geometry, i = s.getAttribute("position"), r = s.index, o = new Float32Array(e.triangleIndices.length * 9);
-    let n = 0;
-    for (const l of e.triangleIndices) {
-      let c, d, g;
-      r ? [c, d, g] = this._getTriangleIndices(r, l) : (c = l * 3, d = l * 3 + 1, g = l * 3 + 2);
-      const m = this._readVertex(i, c).applyMatrix4(e.mesh.matrixWorld), f = this._readVertex(i, d).applyMatrix4(e.mesh.matrixWorld), u = this._readVertex(i, g).applyMatrix4(e.mesh.matrixWorld);
-      o[n++] = m.x, o[n++] = m.y, o[n++] = m.z, o[n++] = f.x, o[n++] = f.y, o[n++] = f.z, o[n++] = u.x, o[n++] = u.y, o[n++] = u.z;
+  _writeWorldFaceGroup(e, t) {
+    const s = t.mesh.geometry, r = s.getAttribute("position"), i = s.index, n = new Float32Array(t.triangleIndices.length * 9);
+    let o = 0;
+    for (const u of t.triangleIndices) {
+      let d, m, p;
+      i ? [d, m, p] = this._getTriangleIndices(i, u) : (d = u * 3, m = u * 3 + 1, p = u * 3 + 2);
+      const g = this._readVertex(r, d).applyMatrix4(t.mesh.matrixWorld), f = this._readVertex(r, m).applyMatrix4(t.mesh.matrixWorld), h = this._readVertex(r, p).applyMatrix4(t.mesh.matrixWorld);
+      n[o++] = g.x, n[o++] = g.y, n[o++] = g.z, n[o++] = f.x, n[o++] = f.y, n[o++] = f.z, n[o++] = h.x, n[o++] = h.y, n[o++] = h.z;
     }
-    const h = t.geometry;
-    h.setAttribute("position", new a.BufferAttribute(o, 3)), h.setIndex(null), h.computeVertexNormals(), h.computeBoundingBox(), h.computeBoundingSphere();
+    const c = e.geometry;
+    c.setAttribute("position", new l.BufferAttribute(n, 3)), c.setIndex(null), c.computeVertexNormals(), c.computeBoundingBox(), c.computeBoundingSphere();
   }
   /** Сравнение двух логических граней */
-  _same(t, e) {
-    return !!t && !!e && t.mesh === e.mesh && t.triangleIndices.length === e.triangleIndices.length && t.triangleIndices.every((s, i) => s === e.triangleIndices[i]);
+  _same(e, t) {
+    return !!e && !!t && e.mesh === t.mesh && e.triangleIndices.length === t.triangleIndices.length && e.triangleIndices.every((s, r) => s === t.triangleIndices[r]);
   }
   /** Подготовка метаданных выбранной грани для инструментов */
-  _prepareFaceMetadata(t) {
-    const { vertexIndexGroups: e, proxyVertexMap: s, lines: i, lineVertexIndexGroups: r } = this._buildFaceVertexGroups(t);
+  _prepareFaceMetadata(e) {
+    const { vertexIndexGroups: t, proxyVertexMap: s, lines: r, lineVertexIndexGroups: i } = this._buildFaceVertexGroups(e);
     this._selectFace.userData.faceInfo = {
-      mesh: t.mesh,
-      faceIndex: t.faceIndex,
-      triangleIndices: t.triangleIndices,
-      vertexIndices: t.vertexIndices,
-      vertexIndexGroups: e,
+      mesh: e.mesh,
+      faceIndex: e.faceIndex,
+      triangleIndices: e.triangleIndices,
+      vertexIndices: e.vertexIndices,
+      vertexIndexGroups: t,
       proxyVertexMap: s,
-      lines: i,
-      lineVertexIndexGroups: r
+      lines: r,
+      lineVertexIndexGroups: i
     };
   }
   /**
    * Центрирует proxy-грань, чтобы TransformControls работали с ней как с обычным объектом.
    * После записи world-space вершин переносит геометрию в локальные координаты proxy mesh.
    */
-  _centerFaceProxy(t) {
-    const e = t.geometry, s = e.getAttribute("position");
+  _centerFaceProxy(e) {
+    const t = e.geometry, s = t.getAttribute("position");
     if (!s || s.count === 0) return;
-    const i = new a.Vector3();
-    for (let r = 0; r < s.count; r++)
-      i.x += s.getX(r), i.y += s.getY(r), i.z += s.getZ(r);
-    i.multiplyScalar(1 / s.count);
-    for (let r = 0; r < s.count; r++)
-      s.setXYZ(r, s.getX(r) - i.x, s.getY(r) - i.y, s.getZ(r) - i.z);
-    s.needsUpdate = !0, t.position.copy(i), t.quaternion.identity(), t.scale.set(1, 1, 1), t.updateMatrixWorld(!0), e.computeBoundingBox(), e.computeBoundingSphere();
+    const r = new l.Vector3();
+    for (let i = 0; i < s.count; i++)
+      r.x += s.getX(i), r.y += s.getY(i), r.z += s.getZ(i);
+    r.multiplyScalar(1 / s.count);
+    for (let i = 0; i < s.count; i++)
+      s.setXYZ(i, s.getX(i) - r.x, s.getY(i) - r.y, s.getZ(i) - r.z);
+    s.needsUpdate = !0, e.position.copy(r), e.quaternion.identity(), e.scale.set(1, 1, 1), e.updateMatrixWorld(!0), t.computeBoundingBox(), t.computeBoundingSphere();
   }
   /** Регистрирует ребро треугольника в edge map */
-  _pushEdge(t, e, s, i) {
-    const r = e < s ? `${e}_${s}` : `${s}_${e}`, o = t.get(r);
-    o ? o.push(i) : t.set(r, [i]);
+  _pushEdge(e, t, s, r) {
+    const i = t < s ? `${t}_${s}` : `${s}_${t}`, n = e.get(i);
+    n ? n.push(r) : e.set(i, [r]);
   }
   /** Строит граф соседства треугольников по общим ребрам */
-  _buildTriangleAdjacency(t, e) {
-    const s = Math.floor(t.count / 3), i = /* @__PURE__ */ new Map(), r = this._buildWeldMap(t, e);
-    for (let h = 0; h < s; h++) {
-      const [l, c, d] = this._getTriangleIndices(t, h), g = r.get(l), m = r.get(c), f = r.get(d);
-      this._pushEdge(i, g, m, h), this._pushEdge(i, m, f, h), this._pushEdge(i, f, g, h);
+  _buildTriangleAdjacency(e, t) {
+    const s = Math.floor(e.count / 3), r = /* @__PURE__ */ new Map(), i = this._buildWeldMap(e, t);
+    for (let c = 0; c < s; c++) {
+      const [u, d, m] = this._getTriangleIndices(e, c), p = i.get(u), g = i.get(d), f = i.get(m);
+      this._pushEdge(r, p, g, c), this._pushEdge(r, g, f, c), this._pushEdge(r, f, p, c);
     }
-    const o = /* @__PURE__ */ new Map();
-    for (let h = 0; h < s; h++)
-      o.set(h, /* @__PURE__ */ new Set());
-    for (const h of i.values())
-      if (!(h.length < 2))
-        for (let l = 0; l < h.length; l++)
-          for (let c = 0; c < h.length; c++)
-            l !== c && o.get(h[l])?.add(h[c]);
     const n = /* @__PURE__ */ new Map();
-    for (const [h, l] of o)
-      n.set(h, Array.from(l));
-    return n;
+    for (let c = 0; c < s; c++)
+      n.set(c, /* @__PURE__ */ new Set());
+    for (const c of r.values())
+      if (!(c.length < 2))
+        for (let u = 0; u < c.length; u++)
+          for (let d = 0; d < c.length; d++)
+            u !== d && n.get(c[u])?.add(c[d]);
+    const o = /* @__PURE__ */ new Map();
+    for (const [c, u] of n)
+      o.set(c, Array.from(u));
+    return o;
   }
   /** Возвращает индексы трех вершин треугольника */
-  _getTriangleIndices(t, e) {
-    return [t.getX(e * 3), t.getX(e * 3 + 1), t.getX(e * 3 + 2)];
+  _getTriangleIndices(e, t) {
+    return [e.getX(t * 3), e.getX(t * 3 + 1), e.getX(t * 3 + 2)];
   }
   /** Читает вершину из position buffer в local space geometry */
-  _readVertex(t, e) {
-    return new a.Vector3(t.getX(e), t.getY(e), t.getZ(e));
+  _readVertex(e, t) {
+    return new l.Vector3(e.getX(t), e.getY(t), e.getZ(t));
   }
   /** Построение ключа вершины по позиции */
-  _vertexKey(t, e, s = 1e-6) {
-    const i = Math.round(t.getX(e) / s), r = Math.round(t.getY(e) / s), o = Math.round(t.getZ(e) / s);
-    return `${i}_${r}_${o}`;
+  _vertexKey(e, t, s = 1e-6) {
+    const r = Math.round(e.getX(t) / s), i = Math.round(e.getY(t) / s), n = Math.round(e.getZ(t) / s);
+    return `${r}_${i}_${n}`;
   }
   /**
    * Строит отображение исходных индексов вершин в "сваренные" ids по координате.
    * Нужно для случаев, когда соседние треугольники визуально делят ребро,
    * но используют разные индексы вершин (например, цилиндрические крышки, UV seams и т.п.).
    */
-  _buildWeldMap(t, e) {
-    const s = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
-    let r = 0;
-    for (let o = 0; o < t.count; o++) {
-      const n = t.getX(o);
-      if (i.has(n)) continue;
-      const h = this._vertexKey(e, n);
-      let l = s.get(h);
-      l == null && (l = r++, s.set(h, l)), i.set(n, l);
+  _buildWeldMap(e, t) {
+    const s = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+    let i = 0;
+    for (let n = 0; n < e.count; n++) {
+      const o = e.getX(n);
+      if (r.has(o)) continue;
+      const c = this._vertexKey(t, o);
+      let u = s.get(c);
+      u == null && (u = i++, s.set(c, u)), r.set(o, u);
     }
-    return i;
+    return r;
   }
   /** Сбрасывает transform proxy-граням */
-  _resetFaceProxyTransform(t) {
-    t.position.set(0, 0, 0), t.quaternion.identity(), t.scale.set(1, 1, 1), t.updateMatrixWorld(!0);
-  }
-  _buildFaceVertexGroups(t) {
-    const s = t.mesh.geometry.getAttribute("position"), i = 1e-6, r = new a.Vector3(), o = t.vertexIndices, n = [], h = /* @__PURE__ */ new Map();
-    for (const m of o) {
-      const f = this._readVertex(s, m), u = [];
-      for (let S = 0; S < s.count; S++)
-        r.fromBufferAttribute(s, S), r.distanceToSquared(f) < i * i && u.push(S);
-      const w = n.length;
-      n.push(u);
-      for (const S of u)
-        h.set(S, w);
+  _resetFaceProxyTransform(e) {
+    e.position.set(0, 0, 0), e.quaternion.identity(), e.scale.set(1, 1, 1), e.updateMatrixWorld(!0);
+  }
+  _buildFaceVertexGroups(e) {
+    const s = e.mesh.geometry.getAttribute("position"), r = 1e-6, i = new l.Vector3(), n = e.vertexIndices, o = [], c = /* @__PURE__ */ new Map();
+    for (const g of n) {
+      const f = this._readVertex(s, g), h = [];
+      for (let y = 0; y < s.count; y++)
+        i.fromBufferAttribute(s, y), i.distanceToSquared(f) < r * r && h.push(y);
+      const v = o.length;
+      o.push(h);
+      for (const y of h)
+        c.set(y, v);
     }
-    const l = [];
-    for (const m of t.proxyVertexMap) {
-      const f = h.get(m);
-      l.push(f ?? -1);
+    const u = [];
+    for (const g of e.proxyVertexMap) {
+      const f = c.get(g);
+      u.push(f ?? -1);
     }
-    const c = this._findChildLines(t.mesh), d = c ? this._buildLineVertexGroups(t, c) : void 0, g = {
-      vertexIndexGroups: n,
-      proxyVertexMap: l
+    const d = this._findChildLines(e.mesh), m = d ? this._buildLineVertexGroups(e, d) : void 0, p = {
+      vertexIndexGroups: o,
+      proxyVertexMap: u
     };
-    return c && (g.lines = c), d && (g.lineVertexIndexGroups = d), g;
+    return d && (p.lines = d), m && (p.lineVertexIndexGroups = m), p;
   }
-  _findChildLines(t) {
-    for (const e of t.children)
-      if (e.isLineSegments)
-        return e;
+  _findChildLines(e) {
+    for (const t of e.children)
+      if (t.isLineSegments)
+        return t;
     return null;
   }
-  _buildLineVertexGroups(t, e) {
-    const i = e.geometry.getAttribute("position"), o = t.mesh.geometry.getAttribute("position"), n = 1e-6, h = new a.Vector3(), l = e.matrixWorld, c = t.mesh.matrixWorld, d = [];
-    for (const g of t.vertexIndices) {
-      const m = this._readVertex(o, g).applyMatrix4(c), f = [];
-      for (let u = 0; u < i.count; u++)
-        h.fromBufferAttribute(i, u).applyMatrix4(l), h.distanceToSquared(m) < n * n && f.push(u);
-      d.push(f);
+  _buildLineVertexGroups(e, t) {
+    const r = t.geometry.getAttribute("position"), n = e.mesh.geometry.getAttribute("position"), o = 1e-6, c = new l.Vector3(), u = t.matrixWorld, d = e.mesh.matrixWorld, m = [];
+    for (const p of e.vertexIndices) {
+      const g = this._readVertex(n, p).applyMatrix4(d), f = [];
+      for (let h = 0; h < r.count; h++)
+        c.fromBufferAttribute(r, h).applyMatrix4(u), c.distanceToSquared(g) < o * o && f.push(h);
+      m.push(f);
     }
-    return d;
+    return m;
   }
 };
-ae = Qt([
-  M(),
-  Ie(0, _("RendererApi")),
-  Ie(1, _("IEditorStore"))
-], ae);
-var Jt = Object.getOwnPropertyDescriptor, es = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? Jt(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, je = (t, e) => (s, i) => e(s, i, t);
-let he = class {
-  constructor(t, e) {
-    this._api = t, this._store = e, this._api.enableCameraLayer(T), this._hoverVertex = this._makeOverlayVertex(this._hoverColor), this._selectVertex = this._makeOverlayVertex(this._selectColor), this._api.addObject(this._hoverVertex, T), this._api.addObject(this._selectVertex, T);
+Ge = wr([
+  w(),
+  ie(0, _("ICameraApi")),
+  ie(1, _("ISceneApi")),
+  ie(2, _("IRaycastApi")),
+  ie(3, _("EditorStore"))
+], Ge);
+var Ar = Object.getOwnPropertyDescriptor, Or = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Ar(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, pt = (e, t) => (s, r) => t(s, r, e);
+let We = class {
+  constructor(e, t) {
+    this._api = e, this._store = t;
+  }
+  /** Режим, которым управляет хендлер, нужен только менеджеру */
+  mode = P.Mesh;
+  /** Фигура, на которую навелись в данный момент */
+  _hoveredMesh = null;
+  /** Фигура, которую выбрали в данный момент */
+  _selectedMesh = null;
+  // Цвета, необходимые для переключения
+  /** Цвет ребер для фигуры, на которую навелись */
+  _hoverColor = Me;
+  /** Цвет ребер для выделенной фигуры */
+  _selectColor = xe;
+  /** Исходные цвета материалов линий для отката */
+  _origLineColors = /* @__PURE__ */ new WeakMap();
+  handle(e, t) {
+    if (this._api.setRaycastMode(this.mode), t === F.Hover) {
+      if (!e) {
+        this._hoveredMesh && this._hoveredMesh !== this._selectedMesh && this._restoreEdgesColor(this._hoveredMesh), this._hoveredMesh = null;
+        return;
+      }
+      const s = e.intersection.object;
+      this._hoveredMesh !== s && (this._hoveredMesh && this._hoveredMesh !== this._selectedMesh && this._restoreEdgesColor(this._hoveredMesh), s !== this._selectedMesh && this._paintEdges(s, this._hoverColor), this._hoveredMesh = s);
+    }
+    if (t === F.Click) {
+      if (!e) {
+        this._selectedMesh && (this._restoreEdgesColor(this._selectedMesh), this._selectedMesh = null, this._store.setSelectedObject(null));
+        return;
+      }
+      const s = e.intersection.object;
+      this._selectedMesh && this._selectedMesh !== s && this._restoreEdgesColor(this._selectedMesh), this._paintEdges(s, this._selectColor), this._selectedMesh = s, this._store.setSelectedObject(s);
+    }
+  }
+  rollback() {
+    this._hoveredMesh && this._restoreEdgesColor(this._hoveredMesh), this._selectedMesh && this._restoreEdgesColor(this._selectedMesh), this._hoveredMesh = this._selectedMesh = null, this._store.setSelectedObject(null);
+  }
+  /** Освобождает ресурсы хендлера, удаляет слушатели и очищает внутренние данные. */
+  dispose() {
+    this.rollback();
+  }
+  /**
+   * Перекрасить рёбра меша и запомнить оригинальный цвет (один раз на LineSegments).
+   */
+  _paintEdges(e, t) {
+    e.children.forEach((s) => {
+      const r = s;
+      if (r.isLineSegments && r.material) {
+        const i = r.material;
+        this._origLineColors.has(r) || this._origLineColors.set(r, i.color.clone()), i.color.setHex(t), i.needsUpdate = !0;
+      }
+    });
+  }
+  /**
+   * Восстановить исходный цвет рёбер меша из WeakMap.
+   * Если исходный цвет не сохранён (на всякий случай) — ничего не меняем.
+   */
+  _restoreEdgesColor(e) {
+    e.children.forEach((t) => {
+      const s = t;
+      if (s.isLineSegments && s.material) {
+        const r = this._origLineColors.get(s);
+        if (r) {
+          const i = s.material;
+          i.color.copy(r), i.needsUpdate = !0;
+        }
+      }
+    });
+  }
+};
+We = Or([
+  w(),
+  pt(0, _("IRaycastApi")),
+  pt(1, _("EditorStore"))
+], We);
+var Cr = Object.getOwnPropertyDescriptor, Ir = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Cr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, ne = (e, t) => (s, r) => t(s, r, e);
+let Ue = class {
+  constructor(e, t, s, r) {
+    this._cameraApi = e, this._sceneApi = t, this._raycastApi = s, this._store = r, this._cameraApi.enableCameraLayer($), this._hoverVertex = Y(this._makeOverlayVertex(this._hoverColor)), this._selectVertex = Y(this._makeOverlayVertex(this._selectColor)), this._sceneApi.addObject(this._hoverVertex, $), this._sceneApi.addObject(this._selectVertex, $);
   }
   /** Режим, которым управляет хендлер, нужен только менеджеру */
-  mode = y.Vertex;
+  mode = P.Vertex;
   _hovered = null;
   _selected = null;
   /** Текущая наведённая вершина. */
@@ -1539,32 +2281,32 @@ let he = class {
   _selectVertex;
   // Цвета, необходимые для переключения
   /** Цвет ребра, на которое навелись */
-  _hoverColor = Z;
+  _hoverColor = Me;
   /** Цвет выделенного ребра */
-  _selectColor = X;
-  handle(t, e) {
-    if (this._api.setRaycastMode(this.mode), e === C.Hover) {
-      if (!t) {
+  _selectColor = xe;
+  handle(e, t) {
+    if (this._raycastApi.setRaycastMode(this.mode), t === F.Hover) {
+      if (!e) {
         this._hoverVertex.visible = !1, this._hovered = null;
         return;
       }
-      const s = t.intersection.object;
+      const s = e.intersection.object;
       if (!s?.isPoints) return;
-      const i = s, r = t.intersection.index ?? -1;
-      if (r < 0) return;
-      this._selected && this._same({ points: i, index: r }, this._selected) ? this._hoverVertex.visible = !1 : (this._writeWorldVertex(this._hoverVertex, i, r), this._hoverVertex.visible = !0);
+      const r = s, i = e.intersection.index ?? -1;
+      if (i < 0) return;
+      this._selected && this._same({ points: r, index: i }, this._selected) ? this._hoverVertex.visible = !1 : (this._writeWorldVertex(this._hoverVertex, r, i), this._hoverVertex.visible = !0);
       return;
     }
-    if (e === C.Click) {
-      if (!t) {
+    if (t === F.Click) {
+      if (!e) {
         this._selectVertex.visible = !1, this._selected = null, this._store.setSelectedObject(null);
         return;
       }
-      const s = t.intersection.object;
+      const s = e.intersection.object;
       if (!s?.isPoints) return;
-      const i = s, r = t.intersection.index ?? -1;
-      if (r < 0) return;
-      this._writeWorldVertex(this._selectVertex, i, r), this._centerVertexOnPoint(this._selectVertex, i, r), this._selectVertex.visible = !0, this._prepareVertexMetadata(i, r), this._store.setSelectedObject(this._selectVertex), this._selected = { points: i, index: r }, this._hovered && this._same(this._hovered, this._selected) && (this._hoverVertex.visible = !1);
+      const r = s, i = e.intersection.index ?? -1;
+      if (i < 0) return;
+      this._writeWorldVertex(this._selectVertex, r, i), this._centerVertexOnPoint(this._selectVertex, r, i), this._selectVertex.visible = !0, this._prepareVertexMetadata(r, i), this._store.setSelectedObject(this._selectVertex), this._selected = { points: r, index: i }, this._hovered && this._same(this._hovered, this._selected) && (this._hoverVertex.visible = !1);
       return;
     }
   }
@@ -1572,83 +2314,85 @@ let he = class {
     this._hoverVertex.visible = !1, this._selectVertex.visible = !1, this._hovered = this._selected = null, this._store.setSelectedObject(null);
   }
   dispose() {
-    this.rollback(), this._api.removeObject(this._hoverVertex), this._api.removeObject(this._selectVertex), this._hoverVertex.geometry.dispose(), this._hoverVertex.material.dispose(), this._selectVertex.geometry.dispose(), this._selectVertex.material.dispose();
-  }
-  _makeOverlayVertex(t, e = lt) {
-    const s = new a.BufferGeometry();
-    s.setAttribute("position", new a.Float32BufferAttribute([0, 0, 0], 3));
-    const i = new a.PointsMaterial({
-      color: t,
-      size: e,
+    this.rollback(), this._sceneApi.removeFromScene(this._hoverVertex), this._sceneApi.removeFromScene(this._selectVertex), this._hoverVertex.geometry.dispose(), this._hoverVertex.material.dispose(), this._selectVertex.geometry.dispose(), this._selectVertex.material.dispose();
+  }
+  _makeOverlayVertex(e, t = gs) {
+    const s = new l.BufferGeometry();
+    s.setAttribute("position", new l.Float32BufferAttribute([0, 0, 0], 3));
+    const r = new l.PointsMaterial({
+      color: e,
+      size: t,
       sizeAttenuation: !1,
       depthTest: !1,
       depthWrite: !1,
       transparent: !0,
       opacity: 1
-    }), r = new a.Points(s, i);
-    return r.renderOrder = 1e3, r.raycast = () => {
-    }, r.layers.set(T), r.visible = !1, r;
+    }), i = new l.Points(s, r);
+    return i.renderOrder = 1e3, i.raycast = () => {
+    }, i.layers.set($), i.visible = !1, i;
   }
   /** Локальную вершину points переводим в world и пишем в target (прокси-точку) */
-  _writeWorldVertex(t, e, s) {
-    const i = e.geometry.getAttribute("position"), r = new a.Vector3(
-      i.getX(s),
-      i.getY(s),
-      i.getZ(s)
-    ).applyMatrix4(e.matrixWorld), o = t.geometry.getAttribute("position");
-    o.setXYZ(0, r.x, r.y, r.z), o.needsUpdate = !0;
+  _writeWorldVertex(e, t, s) {
+    const r = t.geometry.getAttribute("position"), i = new l.Vector3(
+      r.getX(s),
+      r.getY(s),
+      r.getZ(s)
+    ).applyMatrix4(t.matrixWorld), n = e.geometry.getAttribute("position");
+    n.setXYZ(0, i.x, i.y, i.z), n.needsUpdate = !0;
   }
-  _same(t, e) {
-    return !!t && !!e && t.points === e.points && t.index === e.index;
+  _same(e, t) {
+    return !!e && !!t && e.points === t.points && e.index === t.index;
   }
   /** Готовит метаданные для выбранной вершины и пишет их в _selectVertex.userData */
-  _prepareVertexMetadata(t, e) {
-    const s = Ye(t);
+  _prepareVertexMetadata(e, t) {
+    const s = Pt(e);
     if (!s) return;
-    const i = t.geometry.getAttribute("position"), r = new a.Vector3(
-      i.getX(e),
-      i.getY(e),
-      i.getZ(e)
-    ).applyMatrix4(t.matrixWorld), o = new a.Matrix4().copy(s.matrixWorld).invert(), n = r.clone().applyMatrix4(o), l = s.geometry.getAttribute("position"), c = 1e-6, d = c * c, g = new a.Vector3(), m = [];
-    for (let w = 0; w < l.count; w++)
-      g.fromBufferAttribute(l, w), g.distanceToSquared(n) < d && m.push(w);
-    const f = s.children.find((w) => w?.isLineSegments);
-    let u = [];
+    const r = e.geometry.getAttribute("position"), i = new l.Vector3(
+      r.getX(t),
+      r.getY(t),
+      r.getZ(t)
+    ).applyMatrix4(e.matrixWorld), n = new l.Matrix4().copy(s.matrixWorld).invert(), o = i.clone().applyMatrix4(n), u = s.geometry.getAttribute("position"), d = 1e-6, m = d * d, p = new l.Vector3(), g = [];
+    for (let v = 0; v < u.count; v++)
+      p.fromBufferAttribute(u, v), p.distanceToSquared(o) < m && g.push(v);
+    const f = s.children.find((v) => v?.isLineSegments);
+    let h = [];
     if (f) {
-      const w = new a.Matrix4().copy(f.matrixWorld).invert(), S = r.clone().applyMatrix4(w), j = f.geometry.getAttribute("position"), R = new a.Vector3();
-      for (let V = 0; V < j.count; V++)
-        R.fromBufferAttribute(j, V), R.distanceToSquared(S) < d && u.push(V);
+      const v = new l.Matrix4().copy(f.matrixWorld).invert(), y = i.clone().applyMatrix4(v), A = f.geometry.getAttribute("position"), S = new l.Vector3();
+      for (let x = 0; x < A.count; x++)
+        S.fromBufferAttribute(A, x), S.distanceToSquared(y) < m && h.push(x);
     }
     this._selectVertex.userData.vertexInfo = {
-      points: t,
-      index: e,
+      points: e,
+      index: t,
       mesh: s,
-      vertexIndices: m,
+      vertexIndices: g,
       lines: f ?? null,
-      edgeVertexIndices: u
+      edgeVertexIndices: h
     };
   }
   /** Центрует прокси-вершину на выбранной точке */
-  _centerVertexOnPoint(t, e, s) {
-    const i = e.geometry.getAttribute("position"), r = new a.Vector3(
-      i.getX(s),
-      i.getY(s),
-      i.getZ(s)
-    ).applyMatrix4(e.matrixWorld);
-    t.position.copy(r);
-    const o = t.geometry;
-    let n = o.getAttribute("position");
-    (!n || n.count < 1) && (o.setAttribute("position", new a.BufferAttribute(new Float32Array(3), 3)), n = o.getAttribute("position")), n.setXYZ(0, 0, 0, 0), n.needsUpdate = !0, t.quaternion.identity(), t.scale.set(1, 1, 1), t.updateMatrixWorld(!0);
+  _centerVertexOnPoint(e, t, s) {
+    const r = t.geometry.getAttribute("position"), i = new l.Vector3(
+      r.getX(s),
+      r.getY(s),
+      r.getZ(s)
+    ).applyMatrix4(t.matrixWorld);
+    e.position.copy(i);
+    const n = e.geometry;
+    let o = n.getAttribute("position");
+    (!o || o.count < 1) && (n.setAttribute("position", new l.BufferAttribute(new Float32Array(3), 3)), o = n.getAttribute("position")), o.setXYZ(0, 0, 0, 0), o.needsUpdate = !0, e.quaternion.identity(), e.scale.set(1, 1, 1), e.updateMatrixWorld(!0);
   }
 };
-he = es([
-  M(),
-  je(0, _("RendererApi")),
-  je(1, _("IEditorStore"))
-], he);
-class ve {
-  constructor(e, s) {
-    this.api = e, this.store = s, this._unsubscribeTransform = this.api.onTransformChange(() => {
+Ue = Ir([
+  w(),
+  ne(0, _("ICameraApi")),
+  ne(1, _("ISceneApi")),
+  ne(2, _("IRaycastApi")),
+  ne(3, _("EditorStore"))
+], Ue);
+class tt {
+  constructor(t, s) {
+    this.api = t, this.store = s, this._unsubscribeTransform = this.api.onTransformChange(() => {
       this.store.getSelectedObject() && this.store.notifySelectedTransformChange?.();
     });
   }
@@ -1657,8 +2401,8 @@ class ve {
    * Обновляет состояние инструмента под текущее выделение.
    */
   handle() {
-    const e = this.store.getSelectedObject();
-    this.api.setMode(this.mode), e ? this.api.attach(e) : this.api.detach();
+    const t = this.store.getSelectedObject();
+    this.api.setTransformMode(this.mode), t ? this.api.attachTransform(t) : this.api.detachTransform();
   }
   /**
    * Откатывает локальное состояние инструмента при смене инструмента.
@@ -1666,220 +2410,87 @@ class ve {
    * Вызывается менеджером перед активацией другого хендлера.
    */
   rollback() {
-    this.api.detach();
+    this.api.detachTransform();
   }
   /** Освобождение ресурсов хендлера. */
   dispose() {
     this.rollback(), this._unsubscribeTransform && this._unsubscribeTransform();
   }
 }
-var ts = Object.getOwnPropertyDescriptor, ss = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? ts(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Re = (t, e) => (s, i) => e(s, i, t);
-let le = class extends ve {
+var Pr = Object.getOwnPropertyDescriptor, Lr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Pr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, mt = (e, t) => (s, r) => t(s, r, e);
+let Ne = class extends tt {
   /** Инструмент, которым управляет хендлер, нужен только менеджеру */
-  mode = F.Translate;
-  constructor(t, e) {
-    super(t, e);
+  mode = U.Rotate;
+  constructor(e, t) {
+    super(e, t);
   }
 };
-le = ss([
-  M(),
-  Re(0, _("RendererApi")),
-  Re(1, _("IEditorStore"))
-], le);
-var is = Object.getOwnPropertyDescriptor, rs = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? is(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Ve = (t, e) => (s, i) => e(s, i, t);
-let ce = class extends ve {
+Ne = Lr([
+  w(),
+  mt(0, _("ITransformApi")),
+  mt(1, _("EditorStore"))
+], Ne);
+var Er = Object.getOwnPropertyDescriptor, Tr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Er(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, gt = (e, t) => (s, r) => t(s, r, e);
+let Xe = class extends tt {
   /** Инструмент, которым управляет хендлер, нужен только менеджеру */
-  mode = F.Scale;
-  constructor(t, e) {
-    super(t, e);
+  mode = U.Scale;
+  constructor(e, t) {
+    super(e, t);
   }
 };
-ce = rs([
-  M(),
-  Ve(0, _("RendererApi")),
-  Ve(1, _("IEditorStore"))
-], ce);
-var os = Object.getOwnPropertyDescriptor, ns = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? os(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, ke = (t, e) => (s, i) => e(s, i, t);
-let de = class extends ve {
+Xe = Tr([
+  w(),
+  gt(0, _("ITransformApi")),
+  gt(1, _("EditorStore"))
+], Xe);
+var Vr = Object.getOwnPropertyDescriptor, Dr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Vr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, ft = (e, t) => (s, r) => t(s, r, e);
+let Ye = class extends tt {
   /** Инструмент, которым управляет хендлер, нужен только менеджеру */
-  mode = F.Rotate;
-  constructor(t, e) {
-    super(t, e);
-  }
-};
-de = ns([
-  M(),
-  ke(0, _("RendererApi")),
-  ke(1, _("IEditorStore"))
-], de);
-var as = Object.getOwnPropertyDescriptor, hs = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? as(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, He = (t, e) => (s, i) => e(s, i, t);
-let _e = class {
-  constructor(t, e) {
-    this._api = t, this._store = e, this._api.enableCameraLayer(T), this._hoverLine = this._makeOverlayLine(this._hoverColor), this._selectLine = this._makeOverlayLine(this._selectColor), this._api.addObject(this._hoverLine, T), this._api.addObject(this._selectLine, T);
-  }
-  /** Режим, которым управляет хендлер, нужен только менеджеру */
-  mode = y.Edge;
-  /** Текущее наведённое ребро. */
-  _hoverLine;
-  /** Текущее выбранное ребро. */
-  _selectLine;
-  /** Текущее наведённое ребро из массива `LineSegments` модели. */
-  _hovered = null;
-  /** Текущее выбранное ребро из массива `LineSegments` модели. */
-  _selected = null;
-  // Цвета, необходимые для переключения
-  /** Цвет ребра, на которое навелись */
-  _hoverColor = Z;
-  /** Цвет выделенного ребра */
-  _selectColor = X;
-  /** Обработка текущего режима выборки. */
-  handle(t, e) {
-    if (this._api.setRaycastMode(this.mode), e === C.Hover) {
-      if (!t) {
-        this._hoverLine.visible = !1, this._hovered = null;
-        return;
-      }
-      const s = t.intersection.object;
-      if (!s?.isLineSegments) return;
-      const i = s, r = Math.floor((t.intersection.index ?? -1) / 2);
-      if (r < 0) return;
-      this._selected && this._same({ lines: i, seg: r }, this._selected) ? this._hoverLine.visible = !1 : (this._writeWorldSegment(this._hoverLine, i, r), this._hoverLine.visible = !0), this._hovered = { lines: i, seg: r };
-      return;
-    }
-    if (e === C.Click) {
-      if (!t) {
-        this._selectLine.visible = !1, this._selected = null, this._store.setSelectedObject(null);
-        return;
-      }
-      const s = t.intersection.object;
-      if (!s?.isLineSegments) return;
-      const i = s, r = Math.floor((t.intersection.index ?? -1) / 2);
-      if (r < 0) return;
-      this._writeWorldSegment(this._selectLine, i, r), this._centerAndOrientLineOnSegment(this._selectLine, i, r), this._selectLine.visible = !0, this._prepareEdgeMetadata(i, r), this._store.setSelectedObject(this._selectLine), this._selected = { lines: i, seg: r }, this._hovered && this._same(this._hovered, this._selected) && (this._hoverLine.visible = !1);
-    }
-  }
-  /** Откат текущего режима выборки */
-  rollback() {
-    this._hoverLine.visible = !1, this._selectLine.visible = !1, this._hovered = this._selected = null, this._store.setSelectedObject(null);
-  }
-  /** Освобождает ресурсы хендлера, удаляет слушатели и очищает внутренние данные. */
-  dispose() {
-    this.rollback(), this._api.removeObject(this._hoverLine), this._api.removeObject(this._selectLine), this._hoverLine.geometry.dispose(), this._hoverLine.material.dispose(), this._selectLine.geometry.dispose(), this._selectLine.material.dispose();
-  }
-  /** Инициализация буферных линий для режима (hover и click).
-   * На весь режим будет использовано 2 глобальных линии на сцене,
-   * использоваться они будут только для обозначения геометрии ребер конкретной фигуры.
-   */
-  _makeOverlayLine(t) {
-    const e = new a.BufferGeometry();
-    e.setAttribute("position", new a.Float32BufferAttribute(6, 3));
-    const s = new a.LineBasicMaterial({
-      color: t,
-      depthTest: !1,
-      depthWrite: !1,
-      transparent: !0,
-      opacity: 1
-    }), i = new a.Line(e, s);
-    return i.renderOrder = 1e3, i.raycast = () => {
-    }, i.layers.set(T), i.visible = !1, i;
-  }
-  /** Локальные точки сегмента переводим в target (который висит на сцене) */
-  _writeWorldSegment(t, e, s) {
-    const i = e.geometry.getAttribute("position"), r = s * 2, o = r + 1, n = new a.Vector3(i.getX(r), i.getY(r), i.getZ(r)).applyMatrix4(
-      e.matrixWorld
-    ), h = new a.Vector3(i.getX(o), i.getY(o), i.getZ(o)).applyMatrix4(
-      e.matrixWorld
-    ), l = t.geometry.getAttribute("position");
-    l.setXYZ(0, n.x, n.y, n.z), l.setXYZ(1, h.x, h.y, h.z), l.needsUpdate = !0;
-  }
-  _same(t, e) {
-    return !!t && !!e && t.lines === e.lines && t.seg === e.seg;
-  }
-  /** Центрует `THREE.Line` на сегменте и ориентирует её вдоль ребра */
-  _centerAndOrientLineOnSegment(t, e, s) {
-    const i = e.geometry.getAttribute("position"), r = s * 2, o = r + 1, n = new a.Vector3(i.getX(r), i.getY(r), i.getZ(r)).applyMatrix4(
-      e.matrixWorld
-    ), h = new a.Vector3(i.getX(o), i.getY(o), i.getZ(o)).applyMatrix4(
-      e.matrixWorld
-    ), l = new a.Vector3().subVectors(h, n), c = l.length();
-    if (!isFinite(c) || c === 0) return;
-    const d = new a.Vector3().addVectors(n, h).multiplyScalar(0.5);
-    t.position.copy(d);
-    const g = t.geometry;
-    let m = g.getAttribute("position");
-    (!m || m.count < 2) && (g.setAttribute("position", new a.BufferAttribute(new Float32Array(6), 3)), m = g.getAttribute("position")), m.setXYZ(0, -c / 2, 0, 0), m.setXYZ(1, c / 2, 0, 0), m.needsUpdate = !0, l.normalize();
-    const f = new a.Quaternion().setFromUnitVectors(new a.Vector3(1, 0, 0), l);
-    t.quaternion.copy(f), t.updateMatrixWorld(!0);
-  }
-  /** Запись метаданных выбранного ребра для использования инструментов */
-  _prepareEdgeMetadata(t, e) {
-    const s = Ye(t);
-    if (!s) return;
-    const i = t.geometry.getAttribute("position"), r = e * 2, o = r + 1, n = new a.Vector3(i.getX(r), i.getY(r), i.getZ(r)).applyMatrix4(
-      t.matrixWorld
-    ), h = new a.Vector3(i.getX(o), i.getY(o), i.getZ(o)).applyMatrix4(
-      t.matrixWorld
-    ), l = new a.Matrix4().copy(s.matrixWorld).invert(), c = n.clone().applyMatrix4(l), d = h.clone().applyMatrix4(l), m = s.geometry.getAttribute("position"), f = new a.Vector3(), u = 1e-6, w = [], S = [];
-    for (let x = 0; x < m.count; x++)
-      f.fromBufferAttribute(m, x), f.distanceToSquared(c) < u * u ? w.push(x) : f.distanceToSquared(d) < u * u && S.push(x);
-    const j = new a.Matrix4().copy(t.matrixWorld).invert(), R = n.clone().applyMatrix4(j), V = h.clone().applyMatrix4(j), E = t.geometry.getAttribute("position"), O = new a.Vector3(), A = [], k = [];
-    for (let x = 0; x < E.count; x++)
-      O.fromBufferAttribute(E, x), O.distanceToSquared(R) < u * u ? A.push(x) : O.distanceToSquared(V) < u * u && k.push(x);
-    this._selectLine.userData.edgeInfo = {
-      lines: t,
-      seg: e,
-      mesh: s,
-      aIndices: w,
-      bIndices: S,
-      aEdgeIndices: A,
-      bEdgeIndices: k
-    };
+  mode = U.Translate;
+  constructor(e, t) {
+    super(e, t);
   }
 };
-_e = hs([
-  M(),
-  He(0, _("RendererApi")),
-  He(1, _("IEditorStore"))
-], _e);
-var ls = Object.getOwnPropertyDescriptor, cs = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? ls(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, ds = (t, e) => (s, i) => e(s, i, t);
-let ue = class {
-  constructor(t) {
-    this._api = t;
+Ye = Dr([
+  w(),
+  ft(0, _("ITransformApi")),
+  ft(1, _("EditorStore"))
+], Ye);
+var jr = Object.getOwnPropertyDescriptor, $r = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? jr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Rr = (e, t) => (s, r) => t(s, r, e);
+let ge = class {
+  constructor(e) {
+    this._api = e;
   }
   /** Режим редактирования сцены */
-  mode = U.AddFigure;
+  mode = T.AddFigure;
   /** Последняя добавленная фигура, нужно для отката через `ctrl + z`. */
   _lastAddedMesh = null;
   /** Добавление базовых фигур на сцену, которые приписаны в `FigureType`. */
-  handle(t) {
-    const e = ht[t](), s = e.getAttribute("position");
-    s && s.setUsage && s.setUsage(a.DynamicDrawUsage);
-    const i = new a.Mesh(e, ze);
-    i.layers.enable(J);
-    const r = Ue(i.geometry);
-    i.add(r);
-    const o = $e(i.geometry);
-    i.add(o), this._api.addMesh(i), this._lastAddedMesh = i;
+  handle(e) {
+    const t = ms[e](), s = t.getAttribute("position");
+    s && s.setUsage && s.setUsage(l.DynamicDrawUsage);
+    const r = new l.Mesh(t, Ot.clone());
+    r.layers.enable(z);
+    const i = t.index ? t.toNonIndexed() : t, n = N(Et(i));
+    n.layers.enable(z), r.add(n);
+    const o = N(Lt(i));
+    o.layers.enable(z), r.add(o), this._api.addMesh(r), this._lastAddedMesh = r;
   }
   /** Срабатывает только на `ctrl + z`. */
   rollback() {
@@ -1890,26 +2501,26 @@ let ue = class {
     this._lastAddedMesh = null;
   }
 };
-ue = cs([
-  M(),
-  ds(0, _("RendererApi"))
-], ue);
-var _s = Object.getOwnPropertyDescriptor, us = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? _s(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, Fe = (t, e) => (s, i) => e(s, i, t);
-let pe = class {
-  constructor(t, e) {
-    this._api = t, this._store = e;
+ge = $r([
+  w(),
+  Rr(0, _("IMeshApi"))
+], ge);
+var Fr = Object.getOwnPropertyDescriptor, Hr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Fr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, vt = (e, t) => (s, r) => t(s, r, e);
+let qe = class {
+  constructor(e, t) {
+    this._api = e, this._store = t;
   }
   /** Режим редактирования сцены */
-  mode = U.DeleteFigure;
+  mode = T.DeleteFigure;
   /** Последняя удаленная фигура, сохраняем для отката через `ctrl + z` */
   _lastDeletedMesh = null;
   handle() {
-    const t = this._store.getSelectedObject();
-    bt(t) && (this._api.removeMesh(t), this._store.setSelectedObject(null), this._lastDeletedMesh = t);
+    const e = this._store.getSelectedObject();
+    et(e) && !Vt(e) && (this._api.removeMesh(e), this._store.setSelectedObject(null), this._lastDeletedMesh = e);
   }
   /** Срабатывает только на `ctrl + z`. */
   rollback() {
@@ -1920,147 +2531,311 @@ let pe = class {
     this._lastDeletedMesh = null;
   }
 };
-pe = us([
-  M(),
-  Fe(0, _("RendererApi")),
-  Fe(1, _("IEditorStore"))
-], pe);
-var ps = Object.getOwnPropertyDescriptor, ms = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? ps(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, fs = (t, e) => (s, i) => e(s, i, t);
-let me = class {
-  constructor(t) {
-    this._renderer = t;
-  }
-  /** @inheritdoc */
-  addMesh(t) {
-    this._renderer.addMesh(t);
+qe = Hr([
+  w(),
+  vt(0, _("IMeshApi")),
+  vt(1, _("EditorStore"))
+], qe);
+class Br {
+  /**
+   * Parses the given 3D object and generates the OBJ output.
+   *
+   * If the 3D object is composed of multiple children and geometry, they are merged into a single mesh in the file.
+   *
+   * @param {Object3D} object - The 3D object to export.
+   * @return {string} The exported OBJ.
+   */
+  parse(t) {
+    let s = "", r = 0, i = 0, n = 0;
+    const o = new W(), c = new St(), u = new W(), d = new qt(), m = [];
+    function p(h) {
+      let v = 0, y = 0, A = 0;
+      const S = h.geometry, x = new Zt(), b = S.getAttribute("position"), C = S.getAttribute("normal"), M = S.getAttribute("uv"), I = S.getIndex();
+      if (s += "o " + h.name + `
+`, h.material && h.material.name && (s += "usemtl " + h.material.name + `
+`), b !== void 0)
+        for (let O = 0, V = b.count; O < V; O++, v++)
+          o.fromBufferAttribute(b, O), o.applyMatrix4(h.matrixWorld), s += "v " + o.x + " " + o.y + " " + o.z + `
+`;
+      if (M !== void 0)
+        for (let O = 0, V = M.count; O < V; O++, A++)
+          d.fromBufferAttribute(M, O), s += "vt " + d.x + " " + d.y + `
+`;
+      if (C !== void 0) {
+        x.getNormalMatrix(h.matrixWorld);
+        for (let O = 0, V = C.count; O < V; O++, y++)
+          u.fromBufferAttribute(C, O), u.applyMatrix3(x).normalize(), s += "vn " + u.x + " " + u.y + " " + u.z + `
+`;
+      }
+      if (I !== null)
+        for (let O = 0, V = I.count; O < V; O += 3) {
+          for (let D = 0; D < 3; D++) {
+            const H = I.getX(O + D) + 1;
+            m[D] = r + H + (C || M ? "/" + (M ? i + H : "") + (C ? "/" + (n + H) : "") : "");
+          }
+          s += "f " + m.join(" ") + `
+`;
+        }
+      else
+        for (let O = 0, V = b.count; O < V; O += 3) {
+          for (let D = 0; D < 3; D++) {
+            const H = O + D + 1;
+            m[D] = r + H + (C || M ? "/" + (M ? i + H : "") + (C ? "/" + (n + H) : "") : "");
+          }
+          s += "f " + m.join(" ") + `
+`;
+        }
+      r += v, i += A, n += y;
+    }
+    function g(h) {
+      let v = 0;
+      const y = h.geometry, A = h.type, S = y.getAttribute("position");
+      if (s += "o " + h.name + `
+`, S !== void 0)
+        for (let x = 0, b = S.count; x < b; x++, v++)
+          o.fromBufferAttribute(S, x), o.applyMatrix4(h.matrixWorld), s += "v " + o.x + " " + o.y + " " + o.z + `
+`;
+      if (A === "Line") {
+        s += "l ";
+        for (let x = 1, b = S.count; x <= b; x++)
+          s += r + x + " ";
+        s += `
+`;
+      }
+      if (A === "LineSegments")
+        for (let x = 1, b = x + 1, C = S.count; x < C; x += 2, b = x + 1)
+          s += "l " + (r + x) + " " + (r + b) + `
+`;
+      r += v;
+    }
+    function f(h) {
+      let v = 0;
+      const y = h.geometry, A = y.getAttribute("position"), S = y.getAttribute("color");
+      if (s += "o " + h.name + `
+`, A !== void 0) {
+        for (let x = 0, b = A.count; x < b; x++, v++)
+          o.fromBufferAttribute(A, x), o.applyMatrix4(h.matrixWorld), s += "v " + o.x + " " + o.y + " " + o.z, S !== void 0 && (c.fromBufferAttribute(S, x), Kt.workingToColorSpace(c, wt), s += " " + c.r + " " + c.g + " " + c.b), s += `
+`;
+        s += "p ";
+        for (let x = 1, b = A.count; x <= b; x++)
+          s += r + x + " ";
+        s += `
+`;
+      }
+      r += v;
+    }
+    return t.traverse(function(h) {
+      h.isMesh === !0 && p(h), h.isLine === !0 && g(h), h.isPoints === !0 && f(h);
+    }), s;
   }
-  /** @inheritdoc */
-  addMeshes(t) {
-    for (const e of t)
-      this._renderer.addMesh(e);
+}
+var kr = Object.getOwnPropertyDescriptor, zr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? kr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, yt = (e, t) => (s, r) => t(s, r, e);
+let fe = class {
+  constructor(e, t) {
+    this._api = e, this._exportStore = t;
   }
-  /** @inheritdoc */
-  removeMesh(t) {
-    this._renderer.removeMesh(t);
+  /** Режим редактирования сцены */
+  mode = T.Export;
+  /** Экспорт всей сцены в ExportStore для последующей загрузки в виде файла. */
+  handle() {
+    const e = this._api.getScene(), t = xs(e), r = new Br().parse(t), i = Date.now();
+    this._exportStore.setResult({
+      format: "obj",
+      filename: `scene-${i}.obj`,
+      mimeType: "text/plain;charset=utf-8",
+      content: r,
+      createdAt: i
+    });
   }
-  /** @inheritdoc */
-  removeMeshes(t) {
-    for (const e of t)
-      this._renderer.removeMesh(e);
+  rollback() {
   }
-  /** @inheritdoc */
-  getMeshes() {
-    return this._renderer.getMeshes();
+  /** Освобождает ресурсы хендлера. */
+  dispose() {
+    this._exportStore.clearResult();
   }
-  /** @inheritdoc */
-  setMode(t) {
-    this._renderer.setTransformControlsMode(t);
+};
+fe = zr([
+  w(),
+  yt(0, _("ISceneApi")),
+  yt(1, _("ExportStore"))
+], fe);
+var Gr = Object.defineProperty, Wr = Object.getOwnPropertyDescriptor, Ft = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Wr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = (r ? o(t, s, i) : o(i)) || i);
+  return r && i && Gr(t, s, i), i;
+}, bt = (e, t) => (s, r) => t(s, r, e);
+let J = class {
+  constructor(e, t) {
+    this._api = e, this._validator = t;
   }
-  /** @inheritdoc */
-  attach(t) {
-    this._renderer.attachTransformControls(t);
+  /** Режим редактирования сцены */
+  mode = T.Load;
+  handle(e) {
+    const t = [...this._api.getMeshes()];
+    this._api.removeMeshes(t);
+    const s = Dt(e);
+    this._api.addMeshes(s);
   }
-  /** @inheritdoc */
-  detach() {
-    this._renderer.detachTransformControls();
+  rollback() {
   }
-  /** @inheritdoc */
-  setRaycastMode(t) {
-    this._renderer.setRaycastMode(t);
+  /** Освобождает ресурсы хендлера. */
+  dispose() {
   }
-  /** @inheritdoc */
-  addObject(t, e) {
-    this._renderer.addObject(t, e);
+};
+Ft([
+  $t((e) => e._validator)
+], J.prototype, "handle", 1);
+J = Ft([
+  w(),
+  bt(0, _("IMeshApi")),
+  bt(1, _("ObjValidator"))
+], J);
+var Ur = Object.defineProperty, Nr = Object.getOwnPropertyDescriptor, Ht = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Nr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = (r ? o(t, s, i) : o(i)) || i);
+  return r && i && Ur(t, s, i), i;
+}, Mt = (e, t) => (s, r) => t(s, r, e);
+let Q = class {
+  constructor(e, t) {
+    this._api = e, this._validator = t;
   }
-  /** @inheritdoc */
-  removeObject(t) {
-    this._renderer.removeObject(t);
+  /** Режим редактирования сцены */
+  mode = T.LoadFigure;
+  handle(e) {
+    const t = Dt(e);
+    this._api.addMeshes(t);
   }
-  /** @inheritdoc */
-  enableCameraLayer(t) {
-    this._renderer.enableCameraLayer(t);
+  rollback() {
   }
-  /** @inheritdoc */
-  onTransformChange(t) {
-    return this._renderer.onTransformChange(t);
+  /** Освобождает ресурсы хендлера. */
+  dispose() {
   }
 };
-me = ms([
-  M(),
-  fs(0, _("EditorRenderer"))
-], me);
-var gs = Object.getOwnPropertyDescriptor, bs = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? gs(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
-}, W = (t, e) => (s, i) => e(s, i, t);
-let fe = class {
-  constructor(t, e, s, i, r, o) {
-    this._displayManager = t, this._selectManager = e, this._toolManager = s, this._sceneManager = i, this._renderer = r, this._store = o, this.setSelectMode(y.Mesh), this.setToolMode(F.Translate);
+Ht([
+  $t((e) => e._validator)
+], Q.prototype, "handle", 1);
+Q = Ht([
+  w(),
+  Mt(0, _("IMeshApi")),
+  Mt(1, _("ObjValidator"))
+], Q);
+var Xr = Object.getOwnPropertyDescriptor, Yr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Xr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Z = (e, t) => (s, r) => t(s, r, e);
+let Ze = class {
+  constructor(e, t, s, r, i) {
+    this._renderer = e, this._mediator = t, this._store = s, this._exportStore = r, this._controller = i, this.setSelectMode(P.Mesh), this.setToolMode(U.Translate);
+  }
+  setDisplayMode(e) {
+    return this._mediator.send({
+      type: E.Display,
+      payload: [e]
+    });
   }
-  setDisplayMode(t) {
-    this._displayManager.manage(t);
+  setSelectMode(e) {
+    return this._mediator.send({
+      type: E.Select,
+      payload: [e]
+    });
+  }
+  setToolMode(e) {
+    return this._mediator.send({
+      type: E.Tool,
+      payload: [e]
+    });
+  }
+  addFigure(e) {
+    return this._mediator.send({
+      type: E.Scene,
+      payload: [T.AddFigure, e]
+    });
+  }
+  deleteFigure() {
+    return this._mediator.send({
+      type: E.Scene,
+      payload: [T.DeleteFigure]
+    });
   }
-  setSceneMode(t) {
-    this._sceneManager.manage(t);
+  loadFigure(e) {
+    return this._mediator.send({
+      type: E.Scene,
+      payload: [T.LoadFigure, e]
+    });
   }
-  setSelectMode(t) {
-    this._selectManager.manage(t);
+  loadScene(e) {
+    return this._mediator.send({
+      type: E.Scene,
+      payload: [T.Load, e]
+    });
   }
-  setToolMode(t) {
-    this._toolManager.manage(t);
+  exportScene() {
+    return this._exportStore.clearResult(), {
+      response: this._mediator.send({
+        type: E.Scene,
+        payload: [T.Export]
+      }),
+      result: this._exportStore.getResult()
+    };
   }
   resizeRenderer() {
     this._renderer.resize();
   }
-  updateRenderer() {
-    this._renderer.loop();
+  /**
+   * Запускает редактор.
+   * Вызывается после создания хаба.
+   */
+  start() {
+    this._controller.start();
   }
-  addFigure(t, e) {
-    this._sceneManager.manage(t, e);
+  /**
+   * Останавливает редактор.
+   */
+  stop() {
+    this._controller.stop();
   }
   getSelectionStats() {
     return this._store.getSelectionStats();
   }
-  onSelectionStatsChange(t) {
-    const e = this._store.onSelectedObjectChange(() => {
-      t();
+  onSelectionStatsChange(e) {
+    const t = this._store.onSelectedObjectChange(() => {
+      e();
     }), s = this._store.onSelectedTransformChange(() => {
-      t();
+      e();
     });
     return () => {
-      e(), s();
+      t(), s();
     };
   }
   dispose() {
-    this._displayManager.dispose(), this._selectManager.dispose(), this._renderer.dispose();
+    this._mediator.dispose();
   }
 };
-fe = bs([
-  M(),
-  W(0, _("IDisplayManager")),
-  W(1, _("ISelectManager")),
-  W(2, _("IToolManager")),
-  W(3, _("ISceneManager")),
-  W(4, _("EditorRenderer")),
-  W(5, _("IEditorStore"))
-], fe);
-var vs = Object.getOwnPropertyDescriptor, ys = (t, e, s, i) => {
-  for (var r = i > 1 ? void 0 : i ? vs(e, s) : e, o = t.length - 1, n; o >= 0; o--)
-    (n = t[o]) && (r = n(r) || r);
-  return r;
+Ze = Yr([
+  w(),
+  Z(0, _("Renderer")),
+  Z(1, _("IMediator")),
+  Z(2, _("EditorStore")),
+  Z(3, _("ExportStore")),
+  Z(4, _("IController"))
+], Ze);
+var qr = Object.getOwnPropertyDescriptor, Zr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? qr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
 };
-let ge = class {
+let Ke = class {
   /** Текущий режим выборки. */
-  _selectMode = y.Mesh;
+  _selectMode = P.Mesh;
   /** Текущий выбранный инструмент. */
-  _toolType = F.Translate;
+  _toolType = U.Translate;
   /** Выбранный режим отображения. */
-  _displayMode = $.Plane;
+  _displayMode = K.Plane;
   /** Выбранный объект на сцене. */
   _selectedObject = null;
   /** Слушатели событий по изменению выбранного объекта. */
@@ -2068,83 +2843,296 @@ let ge = class {
   /** Слушатели событий трансформации выбранного объекта. */
   _transformListeners = /* @__PURE__ */ new Set();
   constructor() {
-    at(this, {}, { autoBind: !0 });
+    At(this, {}, { autoBind: !0 });
   }
-  /** @inheritdoc */
   getSelectMode() {
     return this._selectMode;
   }
-  /** @inheritdoc */
   getToolType() {
     return this._toolType;
   }
-  /** @inheritdoc */
   getDisplayMode() {
     return this._displayMode;
   }
-  /** @inheritdoc */
-  setSelectMode(t) {
-    this._selectMode = t;
+  setSelectMode(e) {
+    this._selectMode = e;
   }
-  /** @inheritdoc */
-  setToolType(t) {
-    this._toolType = t;
+  setToolType(e) {
+    this._toolType = e;
   }
-  /** @inheritdoc */
-  setDisplayMode(t) {
-    this._displayMode = t;
+  setDisplayMode(e) {
+    this._displayMode = e;
   }
-  /** @inheritdoc */
   getSelectedObject() {
     return this._selectedObject;
   }
-  /** @inheritdoc */
   getSelectionStats() {
-    const t = this._selectedObject;
-    return t ? vt(t) : null;
-  }
-  /** @inheritdoc */
-  setSelectedObject(t) {
-    if (this._selectedObject !== t) {
-      this._selectedObject = t;
-      for (const e of this._selectedListeners) e(this._selectedObject);
+    const e = this._selectedObject;
+    return e ? ys(e) : null;
+  }
+  setSelectedObject(e) {
+    if (this._selectedObject !== e) {
+      this._selectedObject = e;
+      for (const t of this._selectedListeners) t(this._selectedObject);
     }
   }
-  /** @inheritdoc */
-  onSelectedObjectChange(t) {
-    return this._selectedListeners.add(t), () => this._selectedListeners.delete(t);
+  onSelectedObjectChange(e) {
+    return this._selectedListeners.add(e), () => this._selectedListeners.delete(e);
   }
-  /** @inheritdoc */
-  onSelectedTransformChange(t) {
-    return this._transformListeners.add(t), () => this._transformListeners.delete(t);
+  onSelectedTransformChange(e) {
+    return this._transformListeners.add(e), () => this._transformListeners.delete(e);
   }
-  /** @inheritdoc */
   notifySelectedTransformChange() {
-    for (const t of this._transformListeners) t();
+    for (const e of this._transformListeners) e();
   }
 };
-ge = ys([
-  M()
-], ge);
-let We = !1;
-const b = ot.createChildContainer();
-function Ms(t) {
-  return We || (b.registerInstance("Canvas", t), b.registerSingleton("EventBus", Q), b.registerSingleton("EditorRenderer", ee), b.registerSingleton("RendererApi", me), b.registerSingleton("IDisplayHandler", oe), b.registerSingleton("ISelectHandler", ne), b.registerSingleton("ISelectHandler", ae), b.registerSingleton("ISelectHandler", _e), b.registerSingleton("ISelectHandler", he), b.registerSingleton("IToolHandler", le), b.registerSingleton("IToolHandler", ce), b.registerSingleton("IToolHandler", de), b.registerSingleton("ISceneHandler", ue), b.registerSingleton("ISceneHandler", pe), b.registerSingleton("IDisplayManager", te), b.registerSingleton("ISelectManager", se), b.registerSingleton("IToolManager", ie), b.registerSingleton("ISceneManager", re), b.registerSingleton("EditorHub", fe), b.registerSingleton("IEditorStore", ge), We = !0), b;
+Ke = Zr([
+  w()
+], Ke);
+class Bt {
+  _result = null;
+  constructor() {
+    At(
+      this,
+      {
+        _result: os.ref
+      },
+      {
+        autoBind: !0
+      }
+    );
+  }
+  get result() {
+    return this._result;
+  }
+  get hasResult() {
+    return this._result !== null;
+  }
+  setResult(t) {
+    this._result = t;
+  }
+  getResult() {
+    return this._result;
+  }
+  clearResult() {
+    this._result = null;
+  }
+}
+class kt extends Error {
+  constructor(t, s, r, i) {
+    super(s), this.type = t, this.code = r, this.meta = i, this.name = this._name;
+  }
+  _name = "PolicyException";
+}
+class oe extends Error {
+  constructor(t, s, r, i) {
+    super(s), this.type = t, this.code = r, this.meta = i, this.name = this._name;
+  }
+  _name = "ValidationException";
+}
+var Kr = Object.getOwnPropertyDescriptor, Jr = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? Kr(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Qr = (e, t) => (s, r) => t(s, r, e);
+let Je = class {
+  constructor(e) {
+    this._store = e;
+  }
+  check(e) {
+    const t = this._store.getSelectMode();
+    if (!es[t].includes(e))
+      throw new kt(
+        G.NotAllowed,
+        `Tool ${e} is not allowed`,
+        "TOOL_NOT_ALLOWED"
+      );
+  }
+};
+Je = Jr([
+  w(),
+  Qr(0, _("EditorStore"))
+], Je);
+class zt {
+  constructor() {
+  }
+  validate(t) {
+    const s = t.trim();
+    if (!s)
+      throw new oe(
+        G.ValidationError,
+        "File content is empty.",
+        "FILE_CONTENT_EMPTY"
+      );
+    if (!/^v\s+[-+.\deE]+\s+[-+.\deE]+\s+[-+.\deE]+/m.test(s))
+      throw new oe(
+        G.ValidationError,
+        "OBJ content does not contain vertices.",
+        "WRONG_FILE_CONTENT"
+      );
+    if (!/^f\s+/m.test(s))
+      throw new oe(
+        G.ValidationError,
+        "OBJ content does not contain faces.",
+        "WRONG_FILE_CONTENT"
+      );
+  }
+}
+var ei = Object.getOwnPropertyDescriptor, ti = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? ei(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+};
+let ve = class {
+  handle(e) {
+    try {
+      return e();
+    } catch (t) {
+      return t instanceof kt ? {
+        type: t.type,
+        message: t.message,
+        code: t.code,
+        blocked: !0
+      } : t instanceof oe ? {
+        type: t.type,
+        message: t.message,
+        code: t.code,
+        blocked: !0
+      } : t instanceof Error ? {
+        type: G.Error,
+        message: t.message,
+        code: "UNHANDLED_EXCEPTION",
+        blocked: !0
+      } : {
+        type: G.Error,
+        message: "Unknown exception",
+        code: "UNKNOWN_EXCEPTION",
+        blocked: !0
+      };
+    }
+  }
+};
+ve = ti([
+  w()
+], ve);
+var si = Object.getOwnPropertyDescriptor, ri = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? si(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, xt = (e, t) => (s, r) => t(s, r, e);
+let ye = class {
+  constructor(e, t) {
+    this._middlewares = t, this._managers = new Map(e.map((s) => [s.type, s]));
+  }
+  _managers;
+  send(e) {
+    const t = this._managers.get(e.type);
+    if (!t)
+      return {
+        type: G.Error,
+        message: `Manager for feature "${String(e.type)}" not found`,
+        code: "MANAGER_NOT_FOUND",
+        blocked: !0
+      };
+    const s = () => (t.manage(...e.payload), null);
+    return this._middlewares.reduceRight((i, n) => () => n.handle(i), s)();
+  }
+  dispose() {
+    this._managers && this._managers.clear();
+  }
+};
+ye = ri([
+  w(),
+  xt(0, B("IManager")),
+  xt(1, B("IMiddleware"))
+], ye);
+var ii = Object.getOwnPropertyDescriptor, ni = (e, t, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? ii(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (i = o(i) || i);
+  return i;
+}, Le = (e, t) => (s, r) => t(s, r, e);
+let Qe = class {
+  constructor(e, t, s) {
+    this._renderer = e, this._mediator = t, this._controller = s;
+  }
+  addFigure(e) {
+    return this._mediator.send({
+      type: E.Scene,
+      payload: [T.AddFigure, e]
+    });
+  }
+  loadFigure(e) {
+    return this._mediator.send({
+      type: E.Scene,
+      payload: [T.LoadFigure, e]
+    });
+  }
+  loadScene(e) {
+    return this._mediator.send({
+      type: E.Scene,
+      payload: [T.Load, e]
+    });
+  }
+  resizeRenderer() {
+    this._renderer.resize();
+  }
+  /**
+   * Запускает вьювер.
+   * Вызывается после создания хаба.
+   */
+  start() {
+    this._controller.start();
+  }
+  /**
+   * Останавливает вьювер.
+   */
+  stop() {
+    this._controller.stop();
+  }
+  dispose() {
+    this._mediator.dispose();
+  }
+};
+Qe = ni([
+  w(),
+  Le(0, _("Renderer")),
+  Le(1, _("IMediator")),
+  Le(2, _("IController"))
+], Qe);
+let be = !1;
+const a = Jt.createChildContainer();
+function oi(e, t) {
+  return be || (a.registerInstance("Canvas", e), a.registerInstance(
+    "RendererConfig",
+    Tt(jt, t)
+  ), a.registerSingleton("EventBus", je), a.registerSingleton("IController", le), a.registerSingleton("Renderer", ae), a.register("IRenderable", { useToken: "Renderer" }), a.register("IRendererAccess", { useToken: "Renderer" }), a.register("IRendererCameraAccess", { useToken: "Renderer" }), a.register("IRendererDomAccess", { useToken: "Renderer" }), a.register("IRendererSceneAccess", { useToken: "Renderer" }), a.registerSingleton("ToolPolicy", Je), a.registerSingleton("ObjValidator", zt), a.registerSingleton("IMeshApi", ce), a.registerSingleton("IControlsStateApi", Ee), a.registerSingleton("IRaycastApi", Te), a.registerSingleton("ITransformApi", Ve), a.registerSingleton("ICameraApi", he), a.registerSingleton("IDomApi", de), a.registerSingleton("ISceneApi", ue), a.registerSingleton("ControlsModule", _e), a.registerSingleton("GizmoModule", De), a.registerSingleton("RaycastModule", $e), a.registerSingleton("SceneModule", Re), a.register("IUpdatableModule", { useToken: "ControlsModule" }), a.register("IRenderableModule", { useToken: "GizmoModule" }), a.register("IRuntimeModule", { useToken: "RaycastModule" }), a.register("IRuntimeModule", { useToken: "SceneModule" }), a.registerSingleton("IDisplayHandler", ke), a.registerSingleton("ISelectHandler", We), a.registerSingleton("ISelectHandler", Ge), a.registerSingleton("ISelectHandler", ze), a.registerSingleton("ISelectHandler", Ue), a.registerSingleton("IToolHandler", Ye), a.registerSingleton("IToolHandler", Xe), a.registerSingleton("IToolHandler", Ne), a.registerSingleton("ISceneHandler", ge), a.registerSingleton("ISceneHandler", qe), a.registerSingleton("ISceneHandler", fe), a.registerSingleton("ISceneHandler", Q), a.registerSingleton("ISceneHandler", J), a.registerSingleton("DisplayManager", He), a.register("IDisplayManager", { useToken: "DisplayManager" }), a.register("IManager", { useToken: "DisplayManager" }), a.registerSingleton("SelectManager", Be), a.register("ISelectManager", { useToken: "SelectManager" }), a.register("IManager", { useToken: "SelectManager" }), a.registerSingleton("ToolManager", me), a.register("IToolManager", { useToken: "ToolManager" }), a.register("IManager", { useToken: "ToolManager" }), a.registerSingleton("SceneManager", pe), a.register("ISceneManager", { useToken: "SceneManager" }), a.register("IManager", { useToken: "SceneManager" }), a.registerSingleton("IMiddleware", ve), a.registerSingleton("IMediator", ye), a.registerSingleton("EditorHub", Ze), a.registerSingleton("EditorStore", Ke), a.registerSingleton("ExportStore", Bt), be = !0), a;
+}
+function ai(e, t) {
+  return be || (a.registerInstance("Canvas", e), a.registerInstance(
+    "RendererConfig",
+    Tt(jt, t)
+  ), a.registerSingleton("IController", le), a.registerSingleton("Renderer", ae), a.register("IRenderable", { useToken: "Renderer" }), a.register("IRendererAccess", { useToken: "Renderer" }), a.register("IRendererCameraAccess", { useToken: "Renderer" }), a.register("IRendererDomAccess", { useToken: "Renderer" }), a.register("IRendererSceneAccess", { useToken: "Renderer" }), a.registerSingleton("ObjValidator", zt), a.registerSingleton("IMeshApi", ce), a.registerSingleton("ICameraApi", he), a.registerSingleton("IDomApi", de), a.registerSingleton("ISceneApi", ue), a.registerSingleton("ControlsModule", _e), a.registerSingleton("SceneModule", Fe), a.register("IUpdatableModule", { useToken: "ControlsModule" }), a.register("IRuntimeModule", { useToken: "SceneModule" }), a.registerSingleton("ISceneHandler", ge), a.registerSingleton("ISceneHandler", fe), a.registerSingleton("ISceneHandler", Q), a.registerSingleton("ISceneHandler", J), a.registerSingleton("SceneManager", pe), a.register("ISceneManager", { useToken: "SceneManager" }), a.register("IManager", { useToken: "SceneManager" }), a.registerSingleton("IMiddleware", ve), a.registerSingleton("IMediator", ye), a.registerSingleton("ViewerHub", Qe), a.registerSingleton("ExportStore", Bt), be = !0), a;
 }
-let N = null;
-const Cs = (t) => (N || (N = Ms(t)), N.resolve("EditorHub")), As = () => {
-  if (!N)
-    throw new Error("EditorHub is not initialized. Call createAppHub(canvas) first.");
-  return N.resolve("EditorHub");
+let R = null;
+const gi = (e, t) => (R || (R = oi(e, t)), R.resolve("EditorHub")), fi = () => {
+  if (!R)
+    throw new Error("EditorHub is not initialized. Call createEditorHub(canvas) first.");
+  return R.resolve("EditorHub");
+}, vi = (e, t) => (R || (R = ai(e, t)), R.resolve("ViewerHub")), yi = () => {
+  if (!R)
+    throw new Error("ViewerHub is not initialized. Call createViewerHub(canvas) first.");
+  return R.resolve("ViewerHub");
 };
 export {
-  fe as EditorHub,
-  ee as EditorRenderer,
-  Q as EventBus,
-  H as EventTopics,
-  Ds as ObjLoader,
-  Ls as PreviewRenderer,
-  Ne as Renderer,
-  Cs as createAppHub,
-  As as getAppHub
+  Ze as EditorHub,
+  je as EventBus,
+  k as EventTopics,
+  E as FeatureType,
+  mi as ObjLoader,
+  ae as Renderer,
+  Qe as ViewerHub,
+  gi as createEditorHub,
+  vi as createViewerHub,
+  fi as getEditorHub,
+  yi as getViewerHub
 };