@shopware-ag/dive 2.0.2 → 2.1.0

package/build/chunks/FileTypes-CTHWb2IV.mjs

@@ -0,0 +1,1878 @@
+var J = Object.defineProperty;
+var $ = (r, n, t) => n in r ? J(r, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[n] = t;
+var i = (r, n, t) => $(r, typeof n != "symbol" ? n + "" : n, t);
+import { WebGLRenderer as j, PCFSoftShadowMap as tt, PCFShadowMap as et, BasicShadowMap as it, MathUtils as E, Object3D as w, AmbientLight as st, PointLight as nt, SphereGeometry as T, MeshBasicMaterial as z, FrontSide as G, Mesh as S, HemisphereLight as at, DirectionalLight as ot, Vector3 as h, Box3 as I, MeshStandardMaterial as L, Raycaster as F, Color as g, CylinderGeometry as rt, BufferGeometry as U, BufferAttribute as V, BoxGeometry as v, ConeGeometry as ht, LineDashedMaterial as lt, Line as dt, PlaneGeometry as ct, GridHelper as ut, Scene as pt, TOUCH as f, MOUSE as m, EventDispatcher as mt, Spherical as A, Vector2 as p, Quaternion as x, AxesHelper as gt, Matrix4 as _t, OrthographicCamera as ft, Vector4 as wt, Box3Helper as yt, Sphere as bt } from "three";
+import { P as _, U as Dt, H as Et, C as y, a as St, D as C } from "./PerspectiveCamera-8tnOn5YS.mjs";
+import M from "three-spritetext";
+class Pt {
+  constructor() {
+    i(this, "isDIVEClock", !0);
+    i(this, "_lastTime", 0);
+    i(this, "_isRunning", !1);
+    i(this, "_tickers", []);
+  }
+  start() {
+    this._isRunning || (this._isRunning = !0, this._lastTime = performance.now(), requestAnimationFrame(this._tick.bind(this)));
+  }
+  stop() {
+    this._isRunning = !1;
+  }
+  addTicker(n) {
+    this._tickers.find((t) => t.uuid === n.uuid) || this._tickers.push(n);
+  }
+  hasTicker(n) {
+    return this._tickers.find((t) => t.uuid === n.uuid) !== void 0;
+  }
+  removeTicker(n) {
+    const t = this._tickers.findIndex((e) => e.uuid === n.uuid);
+    t !== -1 && this._tickers.splice(t, 1);
+  }
+  dispose() {
+    this.stop(), this._tickers = [], this._isRunning = !1, this._lastTime = 0;
+  }
+  _tick(n) {
+    if (!this._isRunning) return;
+    const t = (n - this._lastTime) / 1e3;
+    this._lastTime = n, this._tickers.forEach((e) => e.tick(t)), requestAnimationFrame(this._tick.bind(this));
+  }
+}
+const H = {
+  canvas: void 0,
+  antialias: !0,
+  alpha: !0,
+  powerPreference: "high-performance",
+  precision: "highp",
+  stencil: !1,
+  depth: !0,
+  logarithmicDepthBuffer: !1,
+  shadows: !0,
+  shadowQuality: "high"
+};
+class Y {
+  constructor(n, t, e) {
+    i(this, "isDIVERenderer", !0);
+    i(this, "_webglrenderer");
+    i(this, "_settings");
+    this._scene = n, this._camera = t, this._settings = {
+      ...H,
+      ...e ?? {}
+    }, this._webglrenderer = this._createWebGLRenderer();
+  }
+  get webglrenderer() {
+    return this._webglrenderer;
+  }
+  get canvas() {
+    return this._webglrenderer.domElement;
+  }
+  render() {
+    this._webglrenderer.render(this._scene, this._camera);
+  }
+  onResize(n, t) {
+    this._webglrenderer.setSize(n, t, !1);
+  }
+  dispose() {
+    this._webglrenderer.dispose();
+  }
+  setCanvas(n) {
+    this._webglrenderer.dispose(), this._settings.canvas = n, this._webglrenderer = this._createWebGLRenderer();
+  }
+  _createWebGLRenderer() {
+    const n = new j(this._settings);
+    return n.shadowMap.enabled = this._settings.shadows, n.shadowMap.type = this._settings.shadowQuality === "high" ? tt : this._settings.shadowQuality === "medium" ? et : it, n.setPixelRatio(window.devicePixelRatio), n;
+  }
+}
+const te = Y;
+class vt {
+  constructor(n, t) {
+    i(this, "isDIVEResizeManager", !0);
+    i(this, "_resizeObserver");
+    i(this, "_width", 0);
+    i(this, "_height", 0);
+    this._renderer = n, this._camera = t, this._resizeObserver = new ResizeObserver((e) => {
+      const s = e[0], { width: a, height: o } = s.contentRect;
+      a === this._width && o === this._height || (this._renderer.onResize(a, o), this._camera.onResize(a, o), this._width = a, this._height = o);
+    }), this._observeCanvas(this._renderer.canvas);
+  }
+  setCanvas(n) {
+    this._resizeObserver.disconnect(), this._observeCanvas(n);
+    const { width: t, height: e } = n.getBoundingClientRect();
+    this._renderer.onResize(t, e), this._camera.onResize(t, e), this._width = t, this._height = e;
+  }
+  dispose() {
+    this._resizeObserver.disconnect();
+  }
+  _observeCanvas(n) {
+    if (n.parentElement)
+      this._resizeObserver.observe(n.parentElement);
+    else {
+      const t = setInterval(() => {
+        n.parentElement && (this._resizeObserver.observe(n.parentElement), clearInterval(t));
+      }, 16);
+    }
+  }
+}
+class O {
+  constructor(n, t, e) {
+    i(this, "isDIVEView", !0);
+    i(this, "uuid", E.generateUUID());
+    i(this, "_paused", !1);
+    i(this, "_renderer");
+    i(this, "_resizeManager");
+    this._scene = n, this._camera = t, this._settings = e, this._renderer = new Y(
+      this._scene,
+      this._camera,
+      this._settings
+    ), this._resizeManager = new vt(
+      this._renderer,
+      this._camera
+    );
+  }
+  get renderer() {
+    return this._renderer;
+  }
+  get camera() {
+    return this._camera;
+  }
+  get canvas() {
+    return this._renderer.canvas;
+  }
+  tick() {
+    this._paused || this._renderer.render();
+  }
+  dispose() {
+    this._resizeManager.dispose(), this._renderer.dispose();
+  }
+  onResize(n, t) {
+    this._renderer.onResize(n, t), this._camera.onResize(n, t);
+  }
+  setCanvas(n) {
+    this._renderer.setCanvas(n), this._resizeManager.setCanvas(n), this.onResize(
+      this._renderer.canvas.clientWidth,
+      this._renderer.canvas.clientHeight
+    );
+  }
+  // TODO: add methods to individually pause and resume the view
+  pause() {
+    this._paused = !0;
+  }
+  resume() {
+    this._paused = !1;
+  }
+}
+class Mt extends w {
+  constructor() {
+    super();
+    i(this, "isDIVELight", !0);
+    i(this, "isDIVEAmbientLight", !0);
+    i(this, "isSelectable", !0);
+    i(this, "_light");
+    this.name = "DIVEAmbientLight", this._light = new st(16777215, 1), this._light.layers.mask = _, this.add(this._light);
+  }
+  setColor(t) {
+    this._light.color = t;
+  }
+  setIntensity(t) {
+    this._light.intensity = t;
+  }
+  setEnabled(t) {
+    this._light.visible = t;
+  }
+}
+class xt extends w {
+  constructor() {
+    super();
+    i(this, "isDIVELight", !0);
+    i(this, "isDIVEPointLight", !0);
+    i(this, "isMovable", !0);
+    i(this, "isSelectable", !0);
+    i(this, "gizmo", null);
+    i(this, "light");
+    i(this, "mesh");
+    this.name = "DIVEPointLight", this.light = new nt(16777215, 1), this.light.layers.mask = _, this.light.castShadow = !0, this.light.shadow.mapSize.width = 512, this.light.shadow.mapSize.height = 512, this.add(this.light);
+    const t = 0.1, e = new T(
+      t,
+      t * 320,
+      t * 320
+    ), s = new z({
+      color: this.light.color,
+      transparent: !0,
+      opacity: 0.8,
+      side: G
+    });
+    this.mesh = new S(e, s), this.mesh.layers.mask = Dt, this.add(this.mesh);
+  }
+  setColor(t) {
+    this.light.color = t, this.mesh.material.color = t;
+  }
+  setIntensity(t) {
+    this.light.intensity = t, this.mesh.material.opacity = t > 0.8 ? 0.8 : t * 0.8;
+  }
+  setEnabled(t) {
+    this.light.visible = t;
+  }
+  onMove() {
+    import("../plugins/state/index.mjs").then(({ State: t }) => {
+      var e;
+      (e = t.get(this.userData.id)) == null || e.performAction("UPDATE_OBJECT", {
+        id: this.userData.id,
+        position: this.position
+      });
+    });
+  }
+  onSelect() {
+    import("../plugins/state/index.mjs").then(({ State: t }) => {
+      var e;
+      (e = t.get(this.userData.id)) == null || e.performAction("SELECT_OBJECT", {
+        id: this.userData.id
+      });
+    });
+  }
+  onDeselect() {
+    import("../plugins/state/index.mjs").then(({ State: t }) => {
+      var e;
+      (e = t.get(this.userData.id)) == null || e.performAction("DESELECT_OBJECT", {
+        id: this.userData.id
+      });
+    });
+  }
+}
+class Tt extends w {
+  constructor() {
+    super();
+    i(this, "isDIVELight", !0);
+    i(this, "isDIVESceneLight", !0);
+    i(this, "isSelectable", !0);
+    i(this, "_hemiLight");
+    i(this, "_dirLight");
+    this.name = "DIVESceneLight", this._hemiLight = new at(16777215, 16777215, 2), this._hemiLight.layers.mask = _, this._hemiLight.position.set(0, 50, 0), this._hemiLight.visible = !0, this.add(this._hemiLight), this._dirLight = new ot(16777215, 3), this._dirLight.layers.mask = _, this._dirLight.position.set(1, 1.75, 1), this._dirLight.position.multiplyScalar(30), this._dirLight.castShadow = !0, this._dirLight.visible = !0, this._dirLight.shadow.mapSize.width = 2048, this._dirLight.shadow.mapSize.height = 2048;
+    const t = 5;
+    this._dirLight.shadow.camera.left = -5, this._dirLight.shadow.camera.right = t, this._dirLight.shadow.camera.top = t, this._dirLight.shadow.camera.bottom = -5, this._dirLight.shadow.camera.far = 3500, this.add(this._dirLight);
+  }
+  setColor(t) {
+    this._hemiLight.color = t, this._dirLight.color = t;
+  }
+  setIntensity(t) {
+    this._hemiLight.intensity = t * 2, this._dirLight.intensity = t * 3;
+  }
+  setEnabled(t) {
+    this._hemiLight.visible = t, this._dirLight.visible = t;
+  }
+}
+const k = (r) => r.parent ? k(r.parent) : r;
+class P extends w {
+  constructor() {
+    super();
+    i(this, "isSelectable", !0);
+    i(this, "isMovable", !0);
+    i(this, "isDIVENode", !0);
+    i(this, "gizmo", null);
+    i(this, "_positionWorldBuffer");
+    i(this, "_boundingBox");
+    this.layers.mask = _, this._positionWorldBuffer = new h(), this._boundingBox = new I();
+  }
+  setPosition(t) {
+    if (!this.parent) {
+      this.position.set(t.x, t.y, t.z);
+      return;
+    }
+    const e = new h(t.x, t.y, t.z);
+    this.position.copy(this.parent.worldToLocal(e)), "isDIVEGroup" in this.parent && this.parent.updateLineTo(this);
+  }
+  setRotation(t) {
+    this.rotation.set(t.x, t.y, t.z);
+  }
+  setScale(t) {
+    this.scale.set(t.x, t.y, t.z);
+  }
+  setVisibility(t) {
+    this.visible = t;
+  }
+  setToWorldOrigin() {
+    this.position.set(0, 0, 0), import("../plugins/state/index.mjs").then(({ State: t }) => {
+      var e;
+      (e = t.get(this.userData.id)) == null || e.performAction("UPDATE_OBJECT", {
+        id: this.userData.id,
+        position: this.getWorldPosition(this._positionWorldBuffer),
+        rotation: this.rotation,
+        scale: this.scale
+      });
+    });
+  }
+  /**
+   * Can be called when the object is moved from a foreign object (gizmo, parent, etc.) to update the object's position.
+   */
+  onMove() {
+    import("../plugins/state/index.mjs").then(({ State: t }) => {
+      var e;
+      (e = t.get(this.userData.id)) == null || e.performAction("UPDATE_OBJECT", {
+        id: this.userData.id,
+        position: this.getWorldPosition(this._positionWorldBuffer),
+        rotation: this.rotation,
+        scale: this.scale
+      });
+    });
+  }
+  onSelect() {
+    import("../plugins/state/index.mjs").then(({ State: t }) => {
+      var e;
+      (e = t.get(this.userData.id)) == null || e.performAction("SELECT_OBJECT", {
+        id: this.userData.id
+      });
+    });
+  }
+  onDeselect() {
+    import("../plugins/state/index.mjs").then(({ State: t }) => {
+      var e;
+      (e = t.get(this.userData.id)) == null || e.performAction("DESELECT_OBJECT", {
+        id: this.userData.id
+      });
+    });
+  }
+}
+class It extends P {
+  constructor() {
+    super();
+    i(this, "isDIVEModel", !0);
+    i(this, "_mesh", null);
+    i(this, "_material", null);
+    i(this, "_assetLoader", null);
+    this.name = "DIVEModel";
+  }
+  async _getAssetLoader() {
+    return this._assetLoader || (this._assetLoader = new (await import("../plugins/assetloader/index.mjs")).AssetLoader()), this._assetLoader;
+  }
+  async setFromURL(t) {
+    const s = await (await this._getAssetLoader()).load(t);
+    return this.setFromGLTF(s), import("../plugins/state/index.mjs").then(({ State: a }) => {
+      var o;
+      (o = a.get(this.userData.id)) == null || o.performAction("MODEL_LOADED", {
+        id: this.userData.id
+      });
+    }), this;
+  }
+  setFromGLTF(t) {
+    return this.clear(), this._boundingBox.makeEmpty(), t.traverse((e) => {
+      e.castShadow = !0, e.receiveShadow = !0, e.layers.mask = this.layers.mask, this._boundingBox.expandByObject(e), !this._mesh && "isMesh" in e && (this._mesh = e, this._material ? this._mesh.material = this._material : this._material = e.material);
+    }), this.add(t), this;
+  }
+  setMaterial(t) {
+    this._material || (this._material = new L()), t.vertexColors !== void 0 && (this._material.vertexColors = t.vertexColors), t.color !== void 0 && this._material.color.set(t.color), t.map !== void 0 && (this._material.map = t.map), t.normalMap !== void 0 && (this._material.normalMap = t.normalMap), t.roughness !== void 0 && (this._material.roughness = t.roughness), t.roughnessMap !== void 0 && (this._material.roughnessMap = t.roughnessMap, this._material.roughnessMap && (this._material.roughness = 1)), t.metalness !== void 0 && (this._material.metalness = t.metalness), t.metalnessMap !== void 0 && (this._material.metalnessMap = t.metalnessMap, this._material.metalnessMap && (this._material.metalness = 1)), this._mesh && (this._mesh.material = this._material);
+  }
+  placeOnFloor() {
+    var a, o, l, c;
+    const t = this.getWorldPosition(this._positionWorldBuffer), e = t.clone();
+    (o = (a = this._mesh) == null ? void 0 : a.geometry) == null || o.computeBoundingBox();
+    const s = (c = (l = this._mesh) == null ? void 0 : l.geometry) == null ? void 0 : c.boundingBox;
+    !s || !this._mesh || (t.y = t.y - this._mesh.localToWorld(s.min.clone()).y, t.y !== e.y && import("../plugins/state/index.mjs").then(({ State: d }) => {
+      var u;
+      (u = d.get(this.userData.id)) == null || u.performAction("UPDATE_OBJECT", {
+        id: this.userData.id,
+        position: t,
+        rotation: this.rotation,
+        scale: this.scale
+      });
+    }));
+  }
+  dropIt() {
+    if (!this.parent) {
+      console.warn(
+        "DIVEModel: dropIt() called on a model that is not in the scene.",
+        this
+      );
+      return;
+    }
+    const t = this._boundingBox.min.y * this.scale.y, e = this.localToWorld(
+      this._boundingBox.getCenter(new h()).multiply(this.scale)
+    );
+    e.y = t + this.position.y;
+    const s = new F(e, new h(0, -1, 0));
+    s.layers.mask = _;
+    const a = s.intersectObjects(
+      k(this).root.children,
+      !0
+    );
+    if (a.length > 0) {
+      const o = a[0].object;
+      o.geometry.computeBoundingBox();
+      const l = o.geometry.boundingBox, c = o.localToWorld(l.max.clone()), d = this.position.clone(), u = this.position.clone().setY(c.y).sub(new h(0, t, 0));
+      if (this.position.copy(u), this.position.y === d.y) return;
+      this.onMove();
+    }
+  }
+}
+class Lt extends P {
+  constructor() {
+    super();
+    i(this, "isDIVEPrimitive", !0);
+    i(this, "_mesh");
+    this._mesh = new S(), this._mesh.layers.mask = _, this._mesh.castShadow = !0, this._mesh.receiveShadow = !0, this._mesh.material = new L(), this.add(this._mesh);
+  }
+  setGeometry(t) {
+    const e = this.assembleGeometry(t);
+    e && (this._mesh.geometry = e, this._boundingBox.setFromObject(this._mesh));
+  }
+  setMaterial(t) {
+    const e = this._mesh.material;
+    t.vertexColors !== void 0 && (e.vertexColors = t.vertexColors), t.color !== void 0 && (e.color = new g(t.color)), t.map !== void 0 && (e.map = t.map), t.normalMap !== void 0 && (e.normalMap = t.normalMap), t.roughness !== void 0 && (e.roughness = t.roughness), t.roughnessMap !== void 0 && (e.roughnessMap = t.roughnessMap, e.roughnessMap && (e.roughness = 1)), t.metalness !== void 0 && (e.metalness = t.metalness), t.metalnessMap !== void 0 && (e.metalnessMap = t.metalnessMap, e.metalnessMap && (e.metalness = 0)), this._mesh && (this._mesh.material = e);
+  }
+  placeOnFloor() {
+    var a, o, l, c;
+    const t = this.getWorldPosition(this._positionWorldBuffer), e = t.clone();
+    (o = (a = this._mesh) == null ? void 0 : a.geometry) == null || o.computeBoundingBox();
+    const s = (c = (l = this._mesh) == null ? void 0 : l.geometry) == null ? void 0 : c.boundingBox;
+    !s || !this._mesh || (t.y = t.y - this._mesh.localToWorld(s.min.clone()).y, t.y !== e.y && import("../plugins/state/index.mjs").then(({ State: d }) => {
+      var u;
+      (u = d.get(this.userData.id)) == null || u.performAction("UPDATE_OBJECT", {
+        id: this.userData.id,
+        position: t,
+        rotation: this.rotation,
+        scale: this.scale
+      });
+    }));
+  }
+  dropIt() {
+    if (!this.parent) {
+      console.warn(
+        "DIVEPrimitive: dropIt() called on a model that is not in the scene.",
+        this
+      );
+      return;
+    }
+    const t = this._boundingBox.min.y * this.scale.y, e = this.localToWorld(
+      this._boundingBox.getCenter(new h()).multiply(this.scale)
+    );
+    e.y = t + this.position.y;
+    const s = new F(e, new h(0, -1, 0));
+    s.layers.mask = _;
+    const a = s.intersectObjects(
+      k(this).root.children,
+      !0
+    );
+    if (a.length > 0) {
+      const o = a[0].object;
+      o.geometry.computeBoundingBox();
+      const l = o.geometry.boundingBox, c = o.localToWorld(l.max.clone()), d = this.position.clone(), u = this.position.clone().setY(c.y).sub(new h(0, t, 0));
+      if (this.position.copy(u), this.position.y === d.y) return;
+      this.onMove();
+    }
+  }
+  assembleGeometry(t) {
+    switch (this._mesh.material.flatShading = !1, t.name.toLowerCase()) {
+      case "cylinder":
+        return this.createCylinderGeometry(t);
+      case "sphere":
+        return this.createSphereGeometry(t);
+      case "pyramid":
+        return this._mesh.material.flatShading = !0, this.createPyramidGeometry(t);
+      case "cube":
+      case "box":
+        return this.createBoxGeometry(t);
+      case "cone":
+        return this.createConeGeometry(t);
+      case "wall":
+        return this.createWallGeometry(t);
+      case "plane":
+        return this.createPlaneGeometry(t);
+      default:
+        return console.warn(
+          "DIVEPrimitive.assembleGeometry: Invalid geometry type:",
+          t.name.toLowerCase()
+        ), null;
+    }
+  }
+  createCylinderGeometry(t) {
+    const e = new rt(
+      t.width / 2,
+      t.width / 2,
+      t.height,
+      64
+    );
+    return e.translate(0, t.height / 2, 0), e;
+  }
+  createSphereGeometry(t) {
+    return new T(t.width / 2, 256, 256);
+  }
+  createPyramidGeometry(t) {
+    const e = new Float32Array([
+      -t.width / 2,
+      0,
+      -t.depth / 2,
+      // 0
+      t.width / 2,
+      0,
+      -t.depth / 2,
+      // 1
+      t.width / 2,
+      0,
+      t.depth / 2,
+      // 2
+      -t.width / 2,
+      0,
+      t.depth / 2,
+      // 3
+      0,
+      t.height,
+      0
+    ]), s = new Uint16Array([
+      0,
+      1,
+      2,
+      0,
+      2,
+      3,
+      0,
+      4,
+      1,
+      1,
+      4,
+      2,
+      2,
+      4,
+      3,
+      3,
+      4,
+      0
+    ]), a = new U();
+    return a.setAttribute(
+      "position",
+      new V(e, 3)
+    ), a.setIndex(new V(s, 1)), a.computeVertexNormals(), a.computeBoundingBox(), a.computeBoundingSphere(), a;
+  }
+  createBoxGeometry(t) {
+    const e = new v(
+      t.width,
+      t.height,
+      t.depth
+    );
+    return e.translate(0, t.height / 2, 0), e;
+  }
+  createConeGeometry(t) {
+    const e = new ht(t.width / 2, t.height, 256);
+    return e.translate(0, t.height / 2, 0), e;
+  }
+  createWallGeometry(t) {
+    const e = new v(
+      t.width,
+      t.height,
+      t.depth || 0.05,
+      16
+    );
+    return e.translate(0, t.height / 2, 0), e;
+  }
+  createPlaneGeometry(t) {
+    const e = new v(
+      t.width,
+      t.height,
+      t.depth
+    );
+    return e.translate(0, t.height / 2, 0), e;
+  }
+}
+class kt extends P {
+  // lines to children
+  constructor() {
+    super();
+    i(this, "isDIVEGroup", !0);
+    i(this, "_members");
+    i(this, "_lines");
+    this.name = "DIVEGroup", this._members = [], this._lines = [];
+  }
+  // children objects
+  get members() {
+    return this._members;
+  }
+  setPosition(t) {
+    super.setPosition(t), this._members.forEach((e) => {
+      "isDIVENode" in e && e.onMove();
+    });
+  }
+  setLinesVisibility(t, e) {
+    if (!e) {
+      this._lines.forEach((a) => {
+        a.visible = t;
+      });
+      return;
+    }
+    const s = this._members.indexOf(e);
+    s !== -1 && (this._lines[s].visible = t);
+  }
+  attach(t) {
+    if (this._members.includes(t))
+      return this;
+    const e = this.createLine();
+    return this.add(e), this._lines.push(e), super.attach(t), this._members.push(t), this._updateLineTo(e, t), this.setLinesVisibility(!0, t), this;
+  }
+  /**
+   * Removes an object from the group.
+   * @param object - The object to remove.
+   * @returns The group instance.
+   */
+  remove(t) {
+    const e = this._members.indexOf(t);
+    if (e === -1)
+      return this;
+    const s = this._lines[e];
+    return super.remove(s), this._lines.splice(e, 1), super.remove(t), this._members.splice(e, 1), this;
+  }
+  updateLineTo(t) {
+    const e = this._members.indexOf(t);
+    e !== -1 && this._updateLineTo(this._lines[e], t);
+  }
+  /**
+   * Creates a line for visualization.
+   */
+  createLine() {
+    const t = new U(), e = new lt({
+      color: 6710886,
+      dashSize: 0.05,
+      gapSize: 0.025
+    }), s = new dt(t, e);
+    return s.visible = !1, s;
+  }
+  /**
+   * Updates a line to the object.
+   */
+  _updateLineTo(t, e) {
+    const s = [
+      new h(0, 0, 0),
+      e.position.clone()
+    ];
+    t.geometry.setFromPoints(s), t.computeLineDistances();
+  }
+  // public setBoundingBoxVisibility(visible: boolean): void {
+  //     this._boxMesh.visible = visible;
+  // }
+  // /**
+  //  * Recalculates the position of the group based on it's bounding box.
+  //  * Children's world positions are kept.
+  //  */
+  // private recalculatePosition(): void {
+  //     // store all children's world positions
+  //     const childrensWorldPositions: Vector3[] = this.children.map((child) => child.getWorldPosition(new Vector3()));
+  //     // calculate new center and set it as the group's position
+  //     const bbcenter = this.updateBB();
+  //     this.position.copy(bbcenter);
+  //     // set childrens's positions so their world positions are kept
+  //     this.children.forEach((child, i) => {
+  //         if (child.uuid === this._boxMesh.uuid) return;
+  //         child.position.copy(this.worldToLocal(childrensWorldPositions[i]));
+  //     });
+  //     DIVECommunication.get(this.userData.id)?.performAction('UPDATE_OBJECT', { id: this.userData.id, position: this.position });
+  // }
+  // /**
+  //  * Updates the bounding box of the group.
+  //  * @returns {Vector3} The new center of the bounding box.
+  //  */
+  // private updateBB(): Vector3 {
+  //     this._boundingBox.makeEmpty();
+  //     if (this.children.length === 1) {
+  //         // because we always have the box mesh as 1 child
+  //         return this.position.clone();
+  //     }
+  //     this.children.forEach((child) => {
+  //         if (child.uuid === this._boxMesh.uuid) return;
+  //         this._boundingBox.expandByObject(child);
+  //     });
+  //     return this._boundingBox.getCenter(new Vector3());
+  // }
+  // private updateBoxMesh(): void {
+  //     if (this.children.length === 1) {
+  //         // because we always have the box mesh as 1 child
+  //         this._boxMesh.visible = false;
+  //         return;
+  //     }
+  //     this._boxMesh.quaternion.copy(this.quaternion.clone().invert());
+  //     this._boxMesh.scale.set(1 / this.scale.x, 1 / this.scale.y, 1 / this.scale.z);
+  //     this._boxMesh.geometry = new BoxGeometry(this._boundingBox.max.x - this._boundingBox.min.x, this._boundingBox.max.y - this._boundingBox.min.y, this._boundingBox.max.z - this._boundingBox.min.z);
+  //     this._boxMesh.visible = true;
+  // }
+}
+class Rt extends S {
+  constructor() {
+    const t = new ct(1, 1);
+    t.scale(1e3, 1e3, 1), t.rotateX(-Math.PI / 2);
+    const e = new L({
+      color: new g(16777215),
+      side: G
+    });
+    super(t, e);
+    i(this, "isDIVEFloor", !0);
+    this.name = "Floor", this.layers.mask = _, this.receiveShadow = !0;
+  }
+  setVisibility(t) {
+    this.visible = t;
+  }
+  setColor(t) {
+    this.material.color = new g(t);
+  }
+}
+class Vt extends w {
+  constructor() {
+    super();
+    i(this, "isDIVERoot", !0);
+    i(this, "_floor");
+    this.name = "Root", this._floor = new Rt(), this.add(this._floor);
+  }
+  get floor() {
+    return this._floor;
+  }
+  computeSceneBB() {
+    const t = new I();
+    return this.children.forEach((e) => {
+      "isDIVEFloor" in e || e.traverse((s) => {
+        "isObject3D" in s && t.expandByObject(s);
+      });
+    }), t;
+  }
+  getSceneObject(t) {
+    let e;
+    return this.traverse((s) => {
+      e || s.userData.id === t.id && (e = s);
+    }), e;
+  }
+  addSceneObject(t) {
+    let e = this.getSceneObject(t);
+    if (e)
+      return console.warn(
+        `DIVERoot.addSceneObject: Scene object with id ${t.id} already exists`
+      ), e;
+    switch (t.entityType) {
+      case "pov":
+        break;
+      case "light": {
+        switch (t.type) {
+          case "scene": {
+            e = new Tt();
+            break;
+          }
+          case "ambient": {
+            e = new Mt();
+            break;
+          }
+          case "point": {
+            e = new xt();
+            break;
+          }
+          default:
+            throw new Error(
+              `DIVERoot.addSceneObject: Unknown light type: ${t.type}`
+            );
+        }
+        e.name = t.name, e.userData.id = t.id, this.add(e), this._updateLight(e, t);
+        break;
+      }
+      case "model": {
+        e = new It(), e.name = t.name, e.userData.id = t.id, e.userData.uri = t.uri, this.add(e), this._updateModel(e, t);
+        break;
+      }
+      case "primitive": {
+        e = new Lt(), e.name = t.name, e.userData.id = t.id, this.add(e), this._updatePrimitive(e, t);
+        break;
+      }
+      case "group": {
+        e = new kt(), e.name = t.name, e.userData.id = t.id, this.add(e), this._updateGroup(e, t);
+        break;
+      }
+      default:
+        throw new Error(
+          `DIVERoot.addSceneObject: Unknown entity type: ${t.entityType}`
+        );
+    }
+    return e;
+  }
+  updateSceneObject(t) {
+    const e = this.getSceneObject(t);
+    if (!e) {
+      console.warn(
+        `DIVERoot.updateSceneObject: Scene object with id ${t.id} does not exist`
+      );
+      return;
+    }
+    switch (t.entityType) {
+      case "pov":
+        break;
+      case "light": {
+        this._updateLight(e, t);
+        break;
+      }
+      case "model": {
+        this._updateModel(e, t);
+        break;
+      }
+      case "primitive": {
+        this._updatePrimitive(e, t);
+        break;
+      }
+      case "group": {
+        this._updateGroup(e, t);
+        break;
+      }
+      default:
+        throw new Error(
+          `DIVERoot.updateSceneObject: Unknown entity type: ${t.entityType}`
+        );
+    }
+  }
+  deleteSceneObject(t) {
+    const e = this.getSceneObject(t);
+    if (!e) {
+      console.warn(
+        `DIVERoot.deleteSceneObject: Object with id ${t.id} not found`
+      );
+      return;
+    }
+    switch (t.entityType) {
+      case "pov":
+        break;
+      case "light": {
+        this._deleteLight(e);
+        break;
+      }
+      case "model": {
+        this._deleteModel(e);
+        break;
+      }
+      case "primitive": {
+        this._deletePrimitive(e);
+        break;
+      }
+      case "group": {
+        this._deleteGroup(e);
+        break;
+      }
+      default:
+        throw new Error(
+          `DIVERoot.deleteSceneObject: Unknown entity type: ${t.entityType}`
+        );
+    }
+  }
+  _updateLight(t, e) {
+    e.name !== void 0 && e.name !== null && (t.name = e.name), e.position !== void 0 && e.position !== null && t.position.set(
+      e.position.x,
+      e.position.y,
+      e.position.z
+    ), e.intensity !== void 0 && e.intensity !== null && t.setIntensity(e.intensity), e.enabled !== void 0 && e.enabled !== null && t.setEnabled(e.enabled), e.color !== void 0 && e.color !== null && t.setColor(new g(e.color)), e.visible !== void 0 && e.visible !== null && (t.visible = e.visible), e.parentId !== void 0 && this._setParent({ ...e, parentId: e.parentId });
+  }
+  _updateModel(t, e) {
+    e.uri !== void 0 && t.setFromURL(e.uri), e.name !== void 0 && (t.name = e.name), e.position !== void 0 && t.setPosition(e.position), e.rotation !== void 0 && t.setRotation(e.rotation), e.scale !== void 0 && t.setScale(e.scale), e.visible !== void 0 && t.setVisibility(e.visible), e.material !== void 0 && t.setMaterial(e.material), e.parentId !== void 0 && this._setParent({ ...e, parentId: e.parentId });
+  }
+  _updatePrimitive(t, e) {
+    e.name !== void 0 && (t.name = e.name), e.geometry !== void 0 && t.setGeometry(e.geometry), e.position !== void 0 && t.setPosition(e.position), e.rotation !== void 0 && t.setRotation(e.rotation), e.scale !== void 0 && t.setScale(e.scale), e.visible !== void 0 && t.setVisibility(e.visible), e.material !== void 0 && t.setMaterial(e.material), e.parentId !== void 0 && this._setParent({ ...e, parentId: e.parentId });
+  }
+  _updateGroup(t, e) {
+    e.name !== void 0 && (t.name = e.name), e.position !== void 0 && t.setPosition(e.position), e.rotation !== void 0 && t.setRotation(e.rotation), e.scale !== void 0 && t.setScale(e.scale), e.visible !== void 0 && t.setVisibility(e.visible), e.bbVisible !== void 0 && t.setLinesVisibility(e.bbVisible), e.parentId !== void 0 && this._setParent({ ...e, parentId: e.parentId });
+  }
+  _deleteLight(t) {
+    this._detachTransformControls(t), t.parent.remove(t);
+  }
+  _deleteModel(t) {
+    this._detachTransformControls(t), t.parent.remove(t);
+  }
+  _deletePrimitive(t) {
+    this._detachTransformControls(t), t.parent.remove(t);
+  }
+  _deleteGroup(t) {
+    this._detachTransformControls(t);
+    for (let e = t.members.length - 1; e >= 0; e--)
+      this.attach(t.members[e]);
+    t.parent.remove(t);
+  }
+  _setParent(t) {
+    const e = this.getSceneObject(t);
+    if (t.parentId !== null) {
+      const s = this.getSceneObject({
+        id: t.parentId,
+        entityType: t.entityType
+      });
+      if (!s) return;
+      s.attach(e);
+    } else
+      this.attach(e);
+  }
+  _detachTransformControls(t) {
+    this._findScene(t).children.find((e) => {
+      "isTransformControls" in e && e.detach();
+    });
+  }
+  _findScene(t) {
+    return t.parent !== null ? this._findScene(t.parent) : t;
+  }
+}
+const At = "#888888", Ct = "#dddddd";
+class Ot extends w {
+  constructor() {
+    super(), this.name = "Grid";
+    const n = new ut(
+      100,
+      100,
+      At,
+      Ct
+    );
+    n.material.depthTest = !1, n.layers.mask = Et, this.add(n);
+  }
+  setVisibility(n) {
+    this.visible = n;
+  }
+}
+const D = {
+  displayFloor: !1,
+  displayGrid: !1,
+  backgroundColor: "#ffffff"
+};
+class Bt extends pt {
+  constructor(t) {
+    super();
+    i(this, "isDIVEScene", !0);
+    i(this, "_root");
+    i(this, "_grid");
+    this.background = new g(
+      (t == null ? void 0 : t.backgroundColor) ?? D.backgroundColor
+    ), this._root = new Vt(), this._root.floor.setVisibility(
+      (t == null ? void 0 : t.displayFloor) ?? D.displayFloor
+    ), this.add(this._root), this._grid = new Ot(), this._grid.setVisibility(
+      (t == null ? void 0 : t.displayGrid) ?? D.displayGrid
+    ), this.add(this._grid);
+  }
+  get root() {
+    return this._root;
+  }
+  get grid() {
+    return this._grid;
+  }
+  setBackground(t) {
+    this.background = new g(t);
+  }
+  computeSceneBB() {
+    return this._root.computeSceneBB();
+  }
+}
+const zt = {
+  enableDamping: !0,
+  dampingFactor: 0.05,
+  enabled: !0,
+  target: new h(),
+  minDistance: 0,
+  maxDistance: 1 / 0,
+  minZoom: 0,
+  maxZoom: 1 / 0,
+  minPolarAngle: 0,
+  maxPolarAngle: Math.PI,
+  minAzimuthAngle: -1 / 0,
+  maxAzimuthAngle: 1 / 0,
+  enableZoom: !0,
+  zoomSpeed: 1,
+  enableRotate: !0,
+  rotateSpeed: 1,
+  enablePan: !0,
+  panSpeed: 1,
+  screenSpacePanning: !0,
+  keyPanSpeed: 7,
+  autoRotate: !1,
+  autoRotateSpeed: 2,
+  keys: {
+    LEFT: "ArrowLeft",
+    UP: "ArrowUp",
+    RIGHT: "ArrowRight",
+    BOTTOM: "ArrowDown"
+  },
+  mouseButtons: {
+    LEFT: m.ROTATE,
+    MIDDLE: m.DOLLY,
+    RIGHT: m.PAN
+  },
+  touches: {
+    ONE: f.ROTATE,
+    TWO: f.DOLLY_PAN
+  }
+}, b = class b extends mt {
+  constructor(t, e, s) {
+    super();
+    // public API
+    i(this, "object");
+    i(this, "domElements");
+    i(this, "enabled", !0);
+    i(this, "target", new h());
+    i(this, "minDistance", 0);
+    i(this, "maxDistance", 1 / 0);
+    i(this, "minZoom", 0);
+    i(this, "maxZoom", 1 / 0);
+    i(this, "minPolarAngle", 0);
+    // radians
+    i(this, "maxPolarAngle", Math.PI);
+    // radians
+    i(this, "minAzimuthAngle", -1 / 0);
+    // radians
+    i(this, "maxAzimuthAngle", 1 / 0);
+    // radians
+    i(this, "enableDamping", !0);
+    i(this, "dampingFactor", 0.05);
+    i(this, "enableZoom", !0);
+    i(this, "zoomSpeed", 1);
+    i(this, "enableRotate", !0);
+    i(this, "rotateSpeed", 1);
+    i(this, "enablePan", !0);
+    i(this, "panSpeed", 1);
+    i(this, "screenSpacePanning", !0);
+    i(this, "keyPanSpeed", 7);
+    i(this, "autoRotate", !1);
+    i(this, "autoRotateSpeed", 2);
+    i(this, "keys", {
+      LEFT: "ArrowLeft",
+      UP: "ArrowUp",
+      RIGHT: "ArrowRight",
+      BOTTOM: "ArrowDown"
+    });
+    i(this, "mouseButtons", {
+      LEFT: m.ROTATE,
+      MIDDLE: m.DOLLY,
+      RIGHT: m.PAN
+    });
+    i(this, "touches", { ONE: f.ROTATE, TWO: f.DOLLY_PAN });
+    i(this, "target0");
+    i(this, "position0");
+    i(this, "zoom0");
+    i(this, "uuid", E.generateUUID());
+    // private state
+    i(this, "state", -1);
+    i(this, "EPS", 1e-6);
+    i(this, "spherical", new A());
+    i(this, "sphericalDelta", new A());
+    i(this, "scale", 1);
+    i(this, "panOffset", new h());
+    i(this, "zoomChanged", !1);
+    i(this, "rotateStart", new p());
+    i(this, "rotateEnd", new p());
+    i(this, "rotateDelta", new p());
+    i(this, "panStart", new p());
+    i(this, "panEnd", new p());
+    i(this, "panDelta", new p());
+    i(this, "dollyStart", new p());
+    i(this, "dollyEnd", new p());
+    i(this, "dollyDelta", new p());
+    i(this, "pointers", []);
+    i(this, "pointerPositions", {});
+    // for update() function
+    i(this, "offset", new h());
+    i(this, "quat");
+    i(this, "quatInverse");
+    i(this, "lastPosition", new h());
+    i(this, "lastQuaternion", new x());
+    i(this, "lastTarget", new h());
+    i(this, "panLeft", (() => {
+      const t = new h();
+      return (e, s) => {
+        t.setFromMatrixColumn(s, 0), t.multiplyScalar(-e), this.panOffset.add(t);
+      };
+    })());
+    i(this, "panUp", (() => {
+      const t = new h();
+      return (e, s) => {
+        this.screenSpacePanning === !0 ? t.setFromMatrixColumn(s, 1) : (t.setFromMatrixColumn(s, 0), t.crossVectors(this.object.up, t)), t.multiplyScalar(e), this.panOffset.add(t);
+      };
+    })());
+    i(this, "onMouseDown", (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 m.DOLLY:
+          if (this.enableZoom === !1) return;
+          this.handleMouseDownDolly(t), this.state = 1;
+          break;
+        case m.ROTATE:
+          if (t.ctrlKey || t.metaKey || t.shiftKey) {
+            if (this.enablePan === !1) return;
+            this.handleMouseDownPan(t), this.state = 2;
+          } else {
+            if (this.enableRotate === !1) return;
+            this.handleMouseDownRotate(t), this.state = 0;
+          }
+          break;
+        case m.PAN:
+          if (t.ctrlKey || t.metaKey || t.shiftKey) {
+            if (this.enableRotate === !1) return;
+            this.handleMouseDownRotate(t), this.state = 0;
+          } else {
+            if (this.enablePan === !1) return;
+            this.handleMouseDownPan(t), this.state = 2;
+          }
+          break;
+        default:
+          this.state = -1;
+      }
+      this.state !== -1 && this.dispatchEvent({ type: "start" });
+    });
+    i(this, "onMouseMove", (t) => {
+      if (this.enabled !== !1)
+        switch (this.state) {
+          case 0:
+            if (this.enableRotate === !1) return;
+            this.handleMouseMoveRotate(t);
+            break;
+          case 1:
+            if (this.enableZoom === !1) return;
+            this.handleMouseMoveDolly(t);
+            break;
+          case 2:
+            if (this.enablePan === !1) return;
+            this.handleMouseMovePan(t);
+            break;
+        }
+    });
+    i(this, "onMouseWheel", (t) => {
+      this.enabled === !1 || this.enableZoom === !1 || this.state !== -1 || (t.preventDefault(), this.dispatchEvent({ type: "start" }), this.handleMouseWheel(t), this.dispatchEvent({ type: "end" }));
+    });
+    i(this, "onKeyDown", (t) => {
+      this.enabled === !1 || this.enablePan === !1 || this.handleKeyDown(t);
+    });
+    i(this, "onTouchStart", (t) => {
+      switch (this.trackPointer(t), this.pointers.length) {
+        case 1:
+          switch (this.touches.ONE) {
+            case f.ROTATE:
+              if (this.enableRotate === !1) return;
+              this.handleTouchStartRotate(t), this.state = 3;
+              break;
+            case f.PAN:
+              if (this.enablePan === !1) return;
+              this.handleTouchStartPan(t), this.state = 4;
+              break;
+            default:
+              this.state = -1;
+          }
+          break;
+        case 2:
+          switch (this.touches.TWO) {
+            case f.DOLLY_PAN:
+              if (this.enableZoom === !1 && this.enablePan === !1)
+                return;
+              this.handleTouchStartDollyPan(t), this.state = 5;
+              break;
+            case f.DOLLY_ROTATE:
+              if (this.enableZoom === !1 && this.enableRotate === !1)
+                return;
+              this.handleTouchStartDollyRotate(t), this.state = 6;
+              break;
+            default:
+              this.state = -1;
+          }
+          break;
+        default:
+          this.state = -1;
+      }
+      this.state !== -1 && this.dispatchEvent({ type: "start" });
+    });
+    i(this, "onTouchMove", (t) => {
+      switch (this.trackPointer(t), this.state) {
+        case 3:
+          if (this.enableRotate === !1) return;
+          this.handleTouchMoveRotate(t), this.update();
+          break;
+        case 4:
+          if (this.enablePan === !1) return;
+          this.handleTouchMovePan(t), this.update();
+          break;
+        case 5:
+          if (this.enableZoom === !1 && this.enablePan === !1)
+            return;
+          this.handleTouchMoveDollyPan(t), this.update();
+          break;
+        case 6:
+          if (this.enableZoom === !1 && this.enableRotate === !1)
+            return;
+          this.handleTouchMoveDollyRotate(t), this.update();
+          break;
+        default:
+          this.state = -1;
+      }
+    });
+    i(this, "onPointerDown", (t) => {
+      if (this.enabled !== !1) {
+        if (this.pointers.length === 0) {
+          const e = t.currentTarget;
+          e.setPointerCapture(t.pointerId), e.addEventListener("pointermove", this.onPointerMove), e.addEventListener("pointerup", this.onPointerUp);
+        }
+        this.isTrackingPointer(t) || (this.addPointer(t), t.pointerType === "touch" ? this.onTouchStart(t) : this.onMouseDown(t));
+      }
+    });
+    i(this, "onPointerMove", (t) => {
+      this.enabled !== !1 && (t.pointerType === "touch" ? this.onTouchMove(t) : this.onMouseMove(t));
+    });
+    i(this, "onPointerUp", (t) => {
+      if (this.removePointer(t), this.pointers.length === 0) {
+        const e = t.currentTarget;
+        e.releasePointerCapture(t.pointerId), e.removeEventListener("pointermove", this.onPointerMove), e.removeEventListener("pointerup", this.onPointerUp), this.dispatchEvent({ type: "end" }), this.state = -1;
+      }
+    });
+    i(this, "onPointerCancel", (t) => {
+      this.removePointer(t);
+    });
+    i(this, "onContextMenu", (t) => {
+      this.enabled !== !1 && t.preventDefault();
+    });
+    this.object = t, this.domElements = Array.isArray(e) ? e : [e], Object.assign(this, s), this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this.quat = new x().setFromUnitVectors(
+      t.up,
+      new h(0, 1, 0)
+    ), this.quatInverse = this.quat.clone().invert(), this.domElements.forEach((a) => this.addEventListeners(a)), this.update();
+  }
+  get domElement() {
+    return this.domElements[0];
+  }
+  tick() {
+    this.enabled && this.update();
+  }
+  getPolarAngle() {
+    return this.spherical.phi;
+  }
+  getAzimuthalAngle() {
+    return this.spherical.theta;
+  }
+  getDistance() {
+    return this.object.position.distanceTo(this.target);
+  }
+  saveState() {
+    this.target0.copy(this.target), this.position0.copy(this.object.position), this.zoom0 = this.object.zoom;
+  }
+  reset() {
+    this.target.copy(this.target0), this.object.position.copy(this.position0), this.object.zoom = this.zoom0, this.object.updateProjectionMatrix(), this.dispatchEvent({ type: "change" }), this.update(), this.state = -1;
+  }
+  update() {
+    return this.offset.copy(this.object.position).sub(this.target), this.offset.applyQuaternion(this.quat), this.spherical.setFromVector3(this.offset), this.autoRotate && this.state === -1 && this.rotateLeft(this.getAutoRotationAngle()), 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), this.spherical.theta = Math.max(
+      this.minAzimuthAngle,
+      Math.min(this.maxAzimuthAngle, this.spherical.theta)
+    ), this.spherical.phi = Math.max(
+      this.minPolarAngle,
+      Math.min(this.maxPolarAngle, this.spherical.phi)
+    ), this.spherical.makeSafe(), this.spherical.radius *= this.scale, this.spherical.radius = Math.max(
+      this.minDistance,
+      Math.min(this.maxDistance, this.spherical.radius)
+    ), this.enableDamping === !0 ? this.target.addScaledVector(this.panOffset, this.dampingFactor) : this.target.add(this.panOffset), this.offset.setFromSpherical(this.spherical), this.offset.applyQuaternion(this.quatInverse), this.object.position.copy(this.target).add(this.offset), 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.scale = 1, this.zoomChanged || this.lastPosition.distanceToSquared(this.object.position) > this.EPS || 8 * (1 - this.lastQuaternion.dot(this.object.quaternion)) > this.EPS || this.lastTarget.distanceToSquared(this.target) > this.EPS ? (this.dispatchEvent({ type: "change" }), this.lastPosition.copy(this.object.position), this.lastQuaternion.copy(this.object.quaternion), this.lastTarget.copy(this.target), this.zoomChanged = !1, !0) : !1;
+  }
+  dispose() {
+    this.domElements.forEach(
+      (t) => this.removeEventListeners(t)
+    ), this.dispatchEvent({ type: "dispose" });
+  }
+  addDomElements(...t) {
+    t.forEach((e) => {
+      this.domElements.includes(e) || (this.domElements.push(e), this.addEventListeners(e));
+    });
+  }
+  removeDomElements(...t) {
+    t.forEach((e) => {
+      const s = this.domElements.indexOf(e);
+      s > -1 && (this.removeEventListeners(e), this.domElements.splice(s, 1));
+    });
+  }
+  setDomElements(...t) {
+    this.removeDomElements(...this.domElements), this.domElements = [], this.addDomElements(...t);
+  }
+  computeEncompassingView(t, e = 0) {
+    const s = t.center, o = t.sphere.radius, l = this.object.fov * (Math.PI / 180), c = this.object.aspect, d = l / 2, u = Math.atan(Math.tan(d) * c), X = o / Math.sin(d), q = o / Math.sin(u), K = Math.max(X, q) * (1 + e), R = this.object.position.clone().sub(this.target).normalize(), Q = R.length() > 1e-3 ? R : new h(0, 0, 1);
+    return {
+      position: s.clone().add(Q.multiplyScalar(K)),
+      target: s
+    };
+  }
+  focusObject(t, e = 0) {
+    const s = new Xt(t), a = this.computeEncompassingView(s, e);
+    this.object.position.copy(a.position), this.target.copy(a.target), this.update();
+  }
+  zoomIn(t) {
+    this.dollyIn(Math.pow(0.95, t ?? b.DEFAULT_ZOOM_FACTOR)), this.update();
+  }
+  zoomOut(t) {
+    this.dollyOut(
+      Math.pow(0.95, t ?? b.DEFAULT_ZOOM_FACTOR)
+    ), this.update();
+  }
+  getState() {
+    return {
+      target: this.target.clone(),
+      azimuthalAngle: this.getAzimuthalAngle(),
+      polarAngle: this.getPolarAngle(),
+      distance: this.getDistance(),
+      position: this.object.position.clone(),
+      quaternion: this.object.quaternion.clone()
+    };
+  }
+  setState(t) {
+    this.target.copy(t.target), this.object.position.copy(t.position), this.object.quaternion.copy(t.quaternion), this.update();
+  }
+  //
+  // Private methods
+  //
+  addEventListeners(t) {
+    t.style.touchAction = "none", t.addEventListener("contextmenu", this.onContextMenu), t.addEventListener("pointerdown", this.onPointerDown), t.addEventListener("pointercancel", this.onPointerCancel), t.addEventListener("wheel", this.onMouseWheel, {
+      passive: !1
+    }), t.addEventListener("keydown", this.onKeyDown);
+  }
+  removeEventListeners(t) {
+    t.removeEventListener("contextmenu", this.onContextMenu), t.removeEventListener("pointerdown", this.onPointerDown), t.removeEventListener("pointercancel", this.onPointerCancel), t.removeEventListener("wheel", this.onMouseWheel), t.removeEventListener("keydown", this.onKeyDown), t.removeEventListener("pointermove", this.onPointerMove), t.removeEventListener("pointerup", this.onPointerUp);
+  }
+  getAutoRotationAngle() {
+    return 2 * Math.PI / 60 / 60 * this.autoRotateSpeed;
+  }
+  getZoomScale() {
+    return Math.pow(0.95, this.zoomSpeed);
+  }
+  rotateLeft(t) {
+    this.sphericalDelta.theta -= t;
+  }
+  rotateUp(t) {
+    this.sphericalDelta.phi -= t;
+  }
+  pan(t, e, s) {
+    const a = new h();
+    if ("isPerspectiveCamera" in this.object) {
+      const o = this.object.position;
+      a.copy(o).sub(this.target);
+      let l = a.length();
+      l *= Math.tan(
+        this.object.fov / 2 * Math.PI / 180
+      ), this.panLeft(
+        2 * t * l / s.clientHeight,
+        this.object.matrix
+      ), this.panUp(
+        2 * e * l / s.clientHeight,
+        this.object.matrix
+      );
+    } else "isOrthographicCamera" in this.object ? (this.panLeft(
+      t * (this.object.right - this.object.left) / this.object.zoom / s.clientWidth,
+      this.object.matrix
+    ), this.panUp(
+      e * (this.object.top - this.object.bottom) / this.object.zoom / s.clientHeight,
+      this.object.matrix
+    )) : (console.warn(
+      "WARNING: OrbitController encountered an unknown camera type - pan disabled."
+    ), this.enablePan = !1);
+  }
+  dollyIn(t) {
+    "isPerspectiveCamera" in this.object || "isOrthographicCamera" in this.object ? this.scale *= t : (console.warn(
+      "WARNING: OrbitController encountered an unknown camera type - dolly/zoom disabled."
+    ), this.enableZoom = !1);
+  }
+  dollyOut(t) {
+    "isPerspectiveCamera" in this.object || "isOrthographicCamera" in this.object ? this.scale /= t : (console.warn(
+      "WARNING: OrbitController encountered an unknown camera type - dolly/zoom disabled."
+    ), this.enableZoom = !1);
+  }
+  // event callbacks
+  handleMouseDownRotate(t) {
+    this.rotateStart.set(t.clientX, t.clientY);
+  }
+  handleMouseDownDolly(t) {
+    this.dollyStart.set(t.clientX, t.clientY);
+  }
+  handleMouseDownPan(t) {
+    this.panStart.set(t.clientX, t.clientY);
+  }
+  handleMouseMoveRotate(t) {
+    this.rotateEnd.set(t.clientX, t.clientY), this.rotateDelta.subVectors(this.rotateEnd, this.rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = t.currentTarget;
+    this.rotateLeft(
+      2 * Math.PI * this.rotateDelta.x / e.clientHeight
+    ), this.rotateUp(
+      2 * Math.PI * this.rotateDelta.y / e.clientHeight
+    ), this.rotateStart.copy(this.rotateEnd), this.update();
+  }
+  handleMouseMoveDolly(t) {
+    this.dollyEnd.set(t.clientX, t.clientY), this.dollyDelta.subVectors(this.dollyEnd, this.dollyStart), this.dollyDelta.y > 0 ? this.dollyIn(this.getZoomScale()) : this.dollyDelta.y < 0 && this.dollyOut(this.getZoomScale()), this.dollyStart.copy(this.dollyEnd), this.update();
+  }
+  handleMouseMovePan(t) {
+    const e = t.currentTarget;
+    this.panEnd.set(t.clientX, t.clientY), this.panDelta.subVectors(this.panEnd, this.panStart).multiplyScalar(this.panSpeed), this.pan(this.panDelta.x, this.panDelta.y, e), this.panStart.copy(this.panEnd), this.update();
+  }
+  handleMouseWheel(t) {
+    t.deltaY < 0 ? this.dollyIn(this.getZoomScale()) : t.deltaY > 0 && this.dollyOut(this.getZoomScale()), this.update();
+  }
+  handleKeyDown(t) {
+    let e = !1;
+    const s = t.currentTarget;
+    switch (t.code) {
+      case this.keys.UP:
+        this.pan(0, this.keyPanSpeed, s), e = !0;
+        break;
+      case this.keys.BOTTOM:
+        this.pan(0, -this.keyPanSpeed, s), e = !0;
+        break;
+      case this.keys.LEFT:
+        this.pan(this.keyPanSpeed, 0, s), e = !0;
+        break;
+      case this.keys.RIGHT:
+        this.pan(-this.keyPanSpeed, 0, s), e = !0;
+        break;
+    }
+    e && (t.preventDefault(), this.update());
+  }
+  handleTouchStartRotate(t) {
+    if (this.pointers.length === 1)
+      this.rotateStart.set(t.pageX, t.pageY);
+    else {
+      const e = this.getSecondPointer(t), s = 0.5 * (t.pageX + e.pageX), a = 0.5 * (t.pageY + e.pageY);
+      this.rotateStart.set(s, a);
+    }
+  }
+  handleTouchStartPan(t) {
+    if (this.pointers.length === 1)
+      this.panStart.set(t.pageX, t.pageY);
+    else {
+      const e = this.getSecondPointer(t), s = 0.5 * (t.pageX + e.pageX), a = 0.5 * (t.pageY + e.pageY);
+      this.panStart.set(s, a);
+    }
+  }
+  handleTouchStartDolly(t) {
+    const e = this.getSecondPointer(t), s = t.pageX - e.pageX, a = t.pageY - e.pageY, o = Math.sqrt(s * s + a * a);
+    this.dollyStart.set(0, o);
+  }
+  handleTouchStartDollyPan(t) {
+    this.enableZoom && this.handleTouchStartDolly(t), this.enablePan && this.handleTouchStartPan(t);
+  }
+  handleTouchStartDollyRotate(t) {
+    this.enableZoom && this.handleTouchStartDolly(t), this.enableRotate && this.handleTouchStartRotate(t);
+  }
+  handleTouchMoveRotate(t) {
+    if (this.pointers.length === 1)
+      this.rotateEnd.set(t.pageX, t.pageY);
+    else {
+      const s = this.getSecondPointer(t), a = 0.5 * (t.pageX + s.pageX), o = 0.5 * (t.pageY + s.pageY);
+      this.rotateEnd.set(a, o);
+    }
+    const e = t.currentTarget;
+    this.rotateDelta.subVectors(this.rotateEnd, this.rotateStart).multiplyScalar(this.rotateSpeed), this.rotateLeft(
+      2 * Math.PI * this.rotateDelta.x / e.clientHeight
+    ), this.rotateUp(
+      2 * Math.PI * this.rotateDelta.y / e.clientHeight
+    ), this.rotateStart.copy(this.rotateEnd);
+  }
+  handleTouchMovePan(t) {
+    if (this.pointers.length === 1)
+      this.panEnd.set(t.pageX, t.pageY);
+    else {
+      const s = this.getSecondPointer(t), a = 0.5 * (t.pageX + s.pageX), o = 0.5 * (t.pageY + s.pageY);
+      this.panEnd.set(a, o);
+    }
+    const e = t.currentTarget;
+    this.panDelta.subVectors(this.panEnd, this.panStart).multiplyScalar(this.panSpeed), this.pan(this.panDelta.x, this.panDelta.y, e), this.panStart.copy(this.panEnd);
+  }
+  handleTouchMoveDolly(t) {
+    const e = this.getSecondPointer(t), s = t.pageX - e.pageX, a = t.pageY - e.pageY, o = Math.sqrt(s * s + a * a);
+    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);
+  }
+  handleTouchMoveDollyPan(t) {
+    this.enableZoom && this.handleTouchMoveDolly(t), this.enablePan && this.handleTouchMovePan(t);
+  }
+  handleTouchMoveDollyRotate(t) {
+    this.enableZoom && this.handleTouchMoveDolly(t), this.enableRotate && this.handleTouchMoveRotate(t);
+  }
+  addPointer(t) {
+    this.pointers.push(t);
+  }
+  removePointer(t) {
+    delete this.pointerPositions[t.pointerId];
+    for (let e = 0; e < this.pointers.length; e++)
+      if (this.pointers[e].pointerId == t.pointerId) {
+        this.pointers.splice(e, 1);
+        return;
+      }
+  }
+  trackPointer(t) {
+    let e = this.pointerPositions[t.pointerId];
+    e === void 0 && (e = new p(), this.pointerPositions[t.pointerId] = e), e.set(t.pageX, t.pageY);
+  }
+  getSecondPointer(t) {
+    return this.pointers[0].pointerId === t.pointerId ? this.pointers[1] : this.pointers[0];
+  }
+  isTrackingPointer(t) {
+    return this.pointers.some(
+      (e) => e.pointerId === t.pointerId
+    );
+  }
+};
+i(b, "DEFAULT_ZOOM_FACTOR", 1);
+let B = b;
+class Gt extends w {
+  constructor() {
+    super();
+    i(this, "_axesHelper");
+    this._axesHelper = new gt(0.5), this._axesHelper.layers.mask = y, this._axesHelper.material.depthTest = !1, this._axesHelper.position.set(0, 0, -1), this._axesHelper.setColors(
+      new g(Wt),
+      new g(Zt),
+      new g(Nt)
+    );
+    const t = new M("X", 0.2, W), e = new M("Y", 0.2, Z), s = new M("Z", 0.2, N);
+    t.layers.mask = y, e.layers.mask = y, s.layers.mask = y, t.position.set(0.7, 0, 0), e.position.set(0, 0.7, 0), s.position.set(0, 0, 0.7), this._axesHelper.add(t), this._axesHelper.add(e), this._axesHelper.add(s);
+  }
+  setFromCameraMatrix(t) {
+    this._axesHelper.rotation.setFromRotationMatrix(
+      new _t().extractRotation(t).invert()
+    );
+  }
+}
+class Ft {
+  constructor(n, t, e) {
+    i(this, "uuid", E.generateUUID());
+    i(this, "_axes");
+    i(this, "_orthographicCamera");
+    i(this, "_restoreViewport", new wt());
+    this._renderer = n, this._scene = t, this._camera = e, this._orthographicCamera = new ft(
+      -1,
+      1,
+      1,
+      -1,
+      0.1,
+      100
+    ), this._orthographicCamera.layers.mask = y, this._scene.add(this._orthographicCamera), this._axes = new Gt(), this._scene.add(this._axes);
+  }
+  tick() {
+    const n = this._scene.background;
+    this._scene.background = null, this._renderer.webglrenderer.getViewport(this._restoreViewport), this._renderer.webglrenderer.setViewport(0, 0, 150, 150), this._renderer.webglrenderer.autoClear = !1, this._axes.setFromCameraMatrix(this._camera.matrix), this._renderer.webglrenderer.render(
+      this._scene,
+      this._orthographicCamera
+    ), this._renderer.webglrenderer.setViewport(this._restoreViewport), this._renderer.webglrenderer.autoClear = !0, this._scene.background = n;
+  }
+  dispose() {
+    this._scene.remove(this._axes), this._scene.remove(this._orthographicCamera);
+  }
+}
+const Ut = `
+                @@@@@@@@@@@@@@@@@@@@@@@              @@@@@@@@@@@@@@@@@@@@@@@
+           @@@@+-:::::::---------------------==------------------------------=#@@@@
+        @@%=::::.......::---------------------------------------------------------+@@
+      @@+:::...........::-----------------------------------------------------------#@@
+    @@=:::.........::::::-------------------------------------------------------------%@
+   @%:::.......:::::::-----------------------------------------------------------------#@
+  @*:::.....:::::-----------------------------------------------------------------------*@
+ @%::::::.::::---------------------------------------------------------------------------@@
+@@-:::::::::-----------------------------------------------------------------------------=@
+@%::::::::--------------------------------------------------------------------------------%@
+@+::::::::--------------------------------=@@@@@%-----------------------------------------%@
+@=:::::::--------------------------------*@@    @@+---------------------------------------#@
+@+:::::::-------------------------------*@        @*--------------------------------------%@
+@#::::::::-----------------------------=@@        @@=-------------------------------------%@
+@@-::::::::----------------------------@@          @@------------------------------------=@
+ @%:::::::::--------------------------*@            @*-----------------------------------@@
+  @*:::::::::-------------------------@@            @@----------------------------------%@
+   @#::::::::::----------------------%@              @%--------------------------------%@
+    @#:::::::::::-------------------=@@              @@=------------------------------%@
+     @@-::::::::::::----------------%@                @%----------------------------=@@
+      @@#::::::::::::::------------*@                  @*--------------------------#@@
+        @@+::::::::::::::::--------@@                  @@------------------------+@@
+          @@*:::::::::::::::::----@@                    @@---------------------+@@
+            @@@-:::::::::::::::--#@                      @#-----------------=%@@
+               @@%-::::::::::::-%@                        @%-------------=%@@
+                  @@@@+:::::::#@@                          @@*-------*@@@@
+                       @@@@@@@                                @@@@@@
+`;
+window.DIVE = {
+  instances: [],
+  get instance() {
+    return window.DIVE.instances[0];
+  }
+};
+const Ht = {
+  autoStart: !0,
+  displayAxes: !1,
+  ...D,
+  ...St,
+  ...H,
+  ...zt
+};
+class Yt {
+  constructor(n) {
+    // descriptive members
+    i(this, "_instanceId", E.generateUUID());
+    i(this, "_settings");
+    i(this, "_views");
+    i(this, "_mainView");
+    i(this, "_scene");
+    i(this, "_clock");
+    i(this, "orientationDisplay");
+    this._settings = {
+      ...Ht,
+      ...n ?? {}
+    }, this._clock = new Pt(), this._scene = new Bt();
+    const t = new O(
+      this._scene,
+      new C(),
+      this._settings
+    );
+    this._clock.addTicker(t), this._views = [t], this._mainView = t, this._settings.autoStart && this.start(), this._settings.displayAxes ? (console.log("displayAxes", this._settings.displayAxes), this.orientationDisplay = new Ft(
+      this.mainView.renderer,
+      this.scene,
+      this.mainView.camera
+    ), this.clock.addTicker(this.orientationDisplay)) : this.orientationDisplay = null, console.log("DIVE 2.1.0 initialized successfully!"), console.log(Ut), window.DIVE.instances.push(this);
+  }
+  /**
+   * @deprecated This static method will be removed in a future version. Please use `import { QuickView, QuickViewSettings, QuickViewDefaultSettings } from '@shopware-ag/dive/quickview'` instead.
+   */
+  static async QuickView(n, t) {
+    return import("../plugins/quickview/index.mjs").then(
+      ({ QuickView: e }) => e(n, t)
+    );
+  }
+  /**
+   * @deprecated This property will be removed in a future version. Please use properties on the DIVE instance and mainView directly.
+   */
+  get engine() {
+    return Object.assign(this, {
+      camera: this.mainView.camera,
+      renderer: this.mainView.renderer,
+      setCanvas: (n) => {
+        this.mainView.setCanvas(n);
+      },
+      start: () => {
+        this.start();
+      },
+      stop: () => {
+        this.stop();
+      },
+      dispose: () => {
+        this.dispose();
+      }
+    });
+  }
+  get views() {
+    return this._views;
+  }
+  get mainView() {
+    return this._mainView;
+  }
+  get canvas() {
+    return this.mainView.canvas;
+  }
+  get scene() {
+    return this._scene;
+  }
+  get clock() {
+    return this._clock;
+  }
+  start() {
+    this._clock.start();
+  }
+  stop() {
+    this._clock.stop();
+  }
+  async dispose() {
+    return new Promise((n) => {
+      this._views.forEach((t) => {
+        t.dispose();
+      }), this._views = [], this.orientationDisplay && (this._clock.removeTicker(this.orientationDisplay), this.orientationDisplay.dispose()), window.DIVE.instances = window.DIVE.instances.filter(
+        (t) => t._instanceId !== this._instanceId
+      ), n();
+    });
+  }
+  createView(n) {
+    const t = new O(
+      this._scene,
+      n ?? new C(),
+      {
+        ...this._settings,
+        canvas: void 0
+        // instantiate new canvas for created view
+      }
+    );
+    return this._views.push(t), this._clock.addTicker(t), this._views.length === 1 && (this._mainView = t), t;
+  }
+  disposeView(n) {
+    this._views = this._views.filter((t) => t !== n), this._clock.removeTicker(n), this._mainView === n && (this._mainView = this._views[0]), n.dispose();
+  }
+}
+const ee = Yt, W = "#c20017", Z = "#00ab26", N = "#0081d4", Wt = W, Zt = Z, Nt = N;
+class Xt extends P {
+  /**
+   * Creates a new BoundingBox instance for the specified 3D object.
+   *
+   * The constructor computes both a bounding box and bounding sphere for the given object.
+   * It handles complex objects with multiple meshes and nested transformations.
+   *
+   * @param object - The 3D object to compute bounding volumes for
+   * @param axisAligned - Whether to create an axis-aligned bounding box (true) or oriented bounding box (false). Defaults to false.
+   * @param wireframeColor - The color for the wireframe helpers. Can be a hex number or ColorRepresentation. Defaults to green (0x00ff00).
+   *
+   * @example
+   * ```typescript
+   * // Create an oriented bounding box (aligned with object's rotation)
+   * const obb = new BoundingBox(mesh, false, 0x00ff00);
+   *
+   * // Create an axis-aligned bounding box (aligned with world coordinates)
+   * const aabb = new BoundingBox(mesh, true, 0xff0000);
+   *
+   * // Use default green color
+   * const defaultBox = new BoundingBox(mesh);
+   * ```
+   */
+  constructor(t, e = !1, s = 65280) {
+    super();
+    /** The computed bounding box (Box3) */
+    i(this, "_box");
+    /** The computed bounding sphere (Sphere) */
+    i(this, "_sphere");
+    /** The center point of the bounding box */
+    i(this, "_center");
+    /** The radius of the bounding sphere */
+    i(this, "_radius");
+    /** Visual helper for the bounding box wireframe */
+    i(this, "_boxHelper");
+    /** Visual helper for the bounding sphere wireframe */
+    i(this, "_sphereHelper");
+    /** The dimensions (width, height, depth) of the bounding box */
+    i(this, "_size");
+    const a = new I();
+    e ? a.setFromObject(t) : (t.updateWorldMatrix(!0, !0), t.traverse((l) => {
+      if (l.isMesh) {
+        const c = l, d = c.geometry.clone();
+        d.applyMatrix4(c.matrixWorld);
+        const u = c.getWorldQuaternion(new x()).invert();
+        d.applyQuaternion(u), d.computeBoundingBox(), d.boundingBox && a.union(d.boundingBox);
+      }
+    })), this.rotation.copy(t.rotation), this._box = a, this._size = a.getSize(new h()), this._center = a.getCenter(new h()), this._boxHelper = new yt(this._box, s), this._boxHelper.visible = !1, this.add(this._boxHelper), this._sphere = a.getBoundingSphere(new bt()), this._radius = this._sphere.radius;
+    const o = new T(this._radius, 32, 32);
+    o.translate(this._center.x, this._center.y, this._center.z), this._sphereHelper = new S(
+      o,
+      new z({ color: s, wireframe: !0 })
+    ), this._sphereHelper.visible = !1, this.add(this._sphereHelper);
+  }
+  /**
+   * Gets the computed bounding box.
+   * @returns The Box3 instance representing the bounding box
+   */
+  get box() {
+    return this._box;
+  }
+  /**
+   * Gets the computed bounding sphere.
+   * @returns The Sphere instance representing the bounding sphere
+   */
+  get sphere() {
+    return this._sphere;
+  }
+  /**
+   * Gets the center point of the bounding box.
+   * @returns A Vector3 representing the center coordinates
+   */
+  get center() {
+    return this._center;
+  }
+  /**
+   * Gets the radius of the bounding sphere.
+   * @returns The radius as a number
+   */
+  get radius() {
+    return this._radius;
+  }
+  /**
+   * Gets the dimensions of the bounding box.
+   * @returns A Vector3 representing width, height, and depth
+   */
+  get size() {
+    return this._size;
+  }
+  /**
+   * Sets the visibility of the bounding box wireframe helper.
+   *
+   * @param visible - Whether the box helper should be visible
+   *
+   * @example
+   * ```typescript
+   * const boundingBox = new BoundingBox(mesh);
+   *
+   * // Show the bounding box wireframe
+   * boundingBox.setBoxHelperVisible(true);
+   *
+   * // Hide the bounding box wireframe
+   * boundingBox.setBoxHelperVisible(false);
+   * ```
+   */
+  setBoxHelperVisible(t) {
+    this._boxHelper.visible = t;
+  }
+  /**
+   * Sets the visibility of the bounding sphere wireframe helper.
+   *
+   * @param visible - Whether the sphere helper should be visible
+   *
+   * @example
+   * ```typescript
+   * const boundingBox = new BoundingBox(mesh);
+   *
+   * // Show the bounding sphere wireframe
+   * boundingBox.setSphereHelperVisible(true);
+   *
+   * // Hide the bounding sphere wireframe
+   * boundingBox.setSphereHelperVisible(false);
+   * ```
+   */
+  setSphereHelperVisible(t) {
+    this._sphereHelper.visible = t;
+  }
+}
+const qt = {
+  glb: {
+    key: "glb",
+    extension: "glb"
+  },
+  gltf: {
+    key: "gltf",
+    extension: "gltf"
+  },
+  usdz: {
+    key: "usdz",
+    extension: "usdz"
+  }
+}, ie = Object.values(qt).map(
+  (r) => r.extension
+);
+export {
+  Wt as A,
+  P as B,
+  Lt as C,
+  Ht as D,
+  Vt as E,
+  Xt as F,
+  At as G,
+  k as H,
+  qt as I,
+  zt as O,
+  ie as S,
+  B as a,
+  Ft as b,
+  Gt as c,
+  Yt as d,
+  Tt as e,
+  It as f,
+  Zt as g,
+  Nt as h,
+  ee as i,
+  Pt as j,
+  H as k,
+  Y as l,
+  te as m,
+  vt as n,
+  D as o,
+  Bt as p,
+  O as q,
+  W as r,
+  Z as s,
+  N as t,
+  Ct as u,
+  Rt as v,
+  Ot as w,
+  kt as x,
+  Mt as y,
+  xt as z
+};