@vkzstudio/muza-ui 1.0.0 → 1.0.1

package/dist/node_modules/@react-three/fiber/dist/events-776716bd.esm.js

@@ -0,0 +1,1311 @@
+import { Raycaster as Fe, OrthographicCamera as Ie, PerspectiveCamera as Be, Scene as He, PCFSoftShadowMap as Q, VSMShadowMap as Ne, PCFShadowMap as qe, BasicShadowMap as Ge, NoToneMapping as Ue, ACESFilmicToneMapping as Ve, WebGLRenderer as We, Camera as $e, Vector3 as X, Vector2 as Xe, Clock as Ye, Layers as Z, RGBAFormat as Ke, UnsignedByteType as Je } from "../../../three/build/three.module.js";
+import * as D from "react";
+import { c as H } from "../../../../_virtual/constants.js";
+import Qe from "../../../zustand/esm/index.js";
+import { suspend as Ze, preload as et, clear as tt } from "../node_modules/suspend-react/index.js";
+import { jsx as Pe } from "react/jsx-runtime";
+import nt from "../../../../_virtual/index4.js";
+import { s as he } from "../../../../_virtual/index5.js";
+const fe = {}, Tt = (e) => void Object.assign(fe, e);
+function rt(e, n) {
+  function o(t, {
+    args: r = [],
+    attach: f,
+    ...l
+  }, c) {
+    let w = `${t[0].toUpperCase()}${t.slice(1)}`, h;
+    if (t === "primitive") {
+      if (l.object === void 0) throw new Error("R3F: Primitives without 'object' are invalid!");
+      const s = l.object;
+      h = I(s, {
+        type: t,
+        root: c,
+        attach: f,
+        primitive: !0
+      });
+    } else {
+      const s = fe[w];
+      if (!s)
+        throw new Error(`R3F: ${w} is not part of the THREE namespace! Did you forget to extend? See: https://docs.pmnd.rs/react-three-fiber/api/objects#using-3rd-party-objects-declaratively`);
+      if (!Array.isArray(r)) throw new Error("R3F: The args prop must be an array!");
+      h = I(new s(...r), {
+        type: t,
+        root: c,
+        attach: f,
+        // Save args in case we need to reconstruct later for HMR
+        memoizedProps: {
+          args: r
+        }
+      });
+    }
+    return h.__r3f.attach === void 0 && (h.isBufferGeometry ? h.__r3f.attach = "geometry" : h.isMaterial && (h.__r3f.attach = "material")), w !== "inject" && ne(h, l), h;
+  }
+  function i(t, r) {
+    let f = !1;
+    if (r) {
+      var l, c;
+      (l = r.__r3f) != null && l.attach ? te(t, r, r.__r3f.attach) : r.isObject3D && t.isObject3D && (t.add(r), f = !0), f || (c = t.__r3f) == null || c.objects.push(r), r.__r3f || I(r, {}), r.__r3f.parent = t, ce(r), B(r);
+    }
+  }
+  function u(t, r, f) {
+    let l = !1;
+    if (r) {
+      var c, w;
+      if ((c = r.__r3f) != null && c.attach)
+        te(t, r, r.__r3f.attach);
+      else if (r.isObject3D && t.isObject3D) {
+        r.parent = t, r.dispatchEvent({
+          type: "added"
+        }), t.dispatchEvent({
+          type: "childadded",
+          child: r
+        });
+        const h = t.children.filter((a) => a !== r), s = h.indexOf(f);
+        t.children = [...h.slice(0, s), r, ...h.slice(s)], l = !0;
+      }
+      l || (w = t.__r3f) == null || w.objects.push(r), r.__r3f || I(r, {}), r.__r3f.parent = t, ce(r), B(r);
+    }
+  }
+  function p(t, r, f = !1) {
+    t && [...t].forEach((l) => _(r, l, f));
+  }
+  function _(t, r, f) {
+    if (r) {
+      var l, c, w;
+      if (r.__r3f && (r.__r3f.parent = null), (l = t.__r3f) != null && l.objects && (t.__r3f.objects = t.__r3f.objects.filter((b) => b !== r)), (c = r.__r3f) != null && c.attach)
+        be(t, r, r.__r3f.attach);
+      else if (r.isObject3D && t.isObject3D) {
+        var h;
+        t.remove(r), (h = r.__r3f) != null && h.root && dt(Y(r), r);
+      }
+      const a = (w = r.__r3f) == null ? void 0 : w.primitive, m = !a && (f === void 0 ? r.dispose !== null : f);
+      if (!a) {
+        var s;
+        p((s = r.__r3f) == null ? void 0 : s.objects, r, m), p(r.children, r, m);
+      }
+      if (delete r.__r3f, m && r.dispose && r.type !== "Scene") {
+        const b = () => {
+          try {
+            r.dispose();
+          } catch {
+          }
+        };
+        typeof IS_REACT_ACT_ENVIRONMENT > "u" ? he.unstable_scheduleCallback(he.unstable_IdlePriority, b) : b();
+      }
+      B(t);
+    }
+  }
+  function g(t, r, f, l) {
+    var c;
+    const w = (c = t.__r3f) == null ? void 0 : c.parent;
+    if (!w) return;
+    const h = o(r, f, t.__r3f.root);
+    if (t.children) {
+      for (const s of t.children)
+        s.__r3f && i(h, s);
+      t.children = t.children.filter((s) => !s.__r3f);
+    }
+    t.__r3f.objects.forEach((s) => i(h, s)), t.__r3f.objects = [], t.__r3f.autoRemovedBeforeAppend || _(w, t), h.parent && (h.__r3f.autoRemovedBeforeAppend = !0), i(w, h), h.raycast && h.__r3f.eventCount && Y(h).getState().internal.interaction.push(h), [l, l.alternate].forEach((s) => {
+      s !== null && (s.stateNode = h, s.ref && (typeof s.ref == "function" ? s.ref(h) : s.ref.current = h));
+    });
+  }
+  const d = () => {
+  };
+  return {
+    reconciler: nt({
+      createInstance: o,
+      removeChild: _,
+      appendChild: i,
+      appendInitialChild: i,
+      insertBefore: u,
+      supportsMutation: !0,
+      isPrimaryRenderer: !1,
+      supportsPersistence: !1,
+      supportsHydration: !1,
+      noTimeout: -1,
+      appendChildToContainer: (t, r) => {
+        if (!r) return;
+        const f = t.getState().scene;
+        f.__r3f && (f.__r3f.root = t, i(f, r));
+      },
+      removeChildFromContainer: (t, r) => {
+        r && _(t.getState().scene, r);
+      },
+      insertInContainerBefore: (t, r, f) => {
+        if (!r || !f) return;
+        const l = t.getState().scene;
+        l.__r3f && u(l, r, f);
+      },
+      getRootHostContext: () => null,
+      getChildHostContext: (t) => t,
+      finalizeInitialChildren(t) {
+        var r;
+        return !!((r = t == null ? void 0 : t.__r3f) != null ? r : {}).handlers;
+      },
+      prepareUpdate(t, r, f, l) {
+        var c;
+        if (((c = t == null ? void 0 : t.__r3f) != null ? c : {}).primitive && l.object && l.object !== t)
+          return [!0];
+        {
+          const {
+            args: h = [],
+            children: s,
+            ...a
+          } = l, {
+            args: m = [],
+            children: b,
+            ...C
+          } = f;
+          if (!Array.isArray(h)) throw new Error("R3F: the args prop must be an array!");
+          if (h.some((M, j) => M !== m[j])) return [!0];
+          const S = Re(t, a, C, !0);
+          return S.changes.length ? [!1, S] : null;
+        }
+      },
+      commitUpdate(t, [r, f], l, c, w, h) {
+        r ? g(t, l, w, h) : ne(t, f);
+      },
+      commitMount(t, r, f, l) {
+        var c;
+        const w = (c = t.__r3f) != null ? c : {};
+        t.raycast && w.handlers && w.eventCount && Y(t).getState().internal.interaction.push(t);
+      },
+      getPublicInstance: (t) => t,
+      prepareForCommit: () => null,
+      preparePortalMount: (t) => I(t.getState().scene),
+      resetAfterCommit: () => {
+      },
+      shouldSetTextContent: () => !1,
+      clearContainer: () => !1,
+      hideInstance(t) {
+        var r;
+        const {
+          attach: f,
+          parent: l
+        } = (r = t.__r3f) != null ? r : {};
+        f && l && be(l, t, f), t.isObject3D && (t.visible = !1), B(t);
+      },
+      unhideInstance(t, r) {
+        var f;
+        const {
+          attach: l,
+          parent: c
+        } = (f = t.__r3f) != null ? f : {};
+        l && c && te(c, t, l), (t.isObject3D && r.visible == null || r.visible) && (t.visible = !0), B(t);
+      },
+      createTextInstance: d,
+      hideTextInstance: d,
+      unhideTextInstance: d,
+      // https://github.com/pmndrs/react-three-fiber/pull/2360#discussion_r916356874
+      // @ts-expect-error
+      getCurrentEventPriority: () => n ? n() : H.DefaultEventPriority,
+      beforeActiveInstanceBlur: () => {
+      },
+      afterActiveInstanceBlur: () => {
+      },
+      detachDeletedInstance: () => {
+      },
+      now: typeof performance < "u" && E.fun(performance.now) ? performance.now : E.fun(Date.now) ? Date.now : () => 0,
+      // https://github.com/pmndrs/react-three-fiber/pull/2360#discussion_r920883503
+      scheduleTimeout: E.fun(setTimeout) ? setTimeout : void 0,
+      cancelTimeout: E.fun(clearTimeout) ? clearTimeout : void 0
+    }),
+    applyProps: ne
+  };
+}
+var ge, ye;
+const ee = (e) => "colorSpace" in e || "outputColorSpace" in e, Me = () => {
+  var e;
+  return (e = fe.ColorManagement) != null ? e : null;
+}, Oe = (e) => e && e.isOrthographicCamera, At = (e) => e && e.hasOwnProperty("current"), J = typeof window < "u" && ((ge = window.document) != null && ge.createElement || ((ye = window.navigator) == null ? void 0 : ye.product) === "ReactNative") ? D.useLayoutEffect : D.useEffect;
+function ot(e) {
+  const n = D.useRef(e);
+  return J(() => void (n.current = e), [e]), n;
+}
+function kt({
+  set: e
+}) {
+  return J(() => (e(new Promise(() => null)), () => e(!1)), [e]), null;
+}
+class it extends D.Component {
+  constructor(...n) {
+    super(...n), this.state = {
+      error: !1
+    };
+  }
+  componentDidCatch(n) {
+    this.props.set(n);
+  }
+  render() {
+    return this.state.error ? null : this.props.children;
+  }
+}
+it.getDerivedStateFromError = () => ({
+  error: !0
+});
+const xe = "__default", _e = /* @__PURE__ */ new Map(), st = (e) => e && !!e.memoized && !!e.changes;
+function je(e) {
+  var n;
+  const o = typeof window < "u" ? (n = window.devicePixelRatio) != null ? n : 2 : 1;
+  return Array.isArray(e) ? Math.min(Math.max(e[0], o), e[1]) : e;
+}
+const G = (e) => {
+  var n;
+  return (n = e.__r3f) == null ? void 0 : n.root.getState();
+};
+function Y(e) {
+  let n = e.__r3f.root;
+  for (; n.getState().previousRoot; ) n = n.getState().previousRoot;
+  return n;
+}
+const E = {
+  obj: (e) => e === Object(e) && !E.arr(e) && typeof e != "function",
+  fun: (e) => typeof e == "function",
+  str: (e) => typeof e == "string",
+  num: (e) => typeof e == "number",
+  boo: (e) => typeof e == "boolean",
+  und: (e) => e === void 0,
+  arr: (e) => Array.isArray(e),
+  equ(e, n, {
+    arrays: o = "shallow",
+    objects: i = "reference",
+    strict: u = !0
+  } = {}) {
+    if (typeof e != typeof n || !!e != !!n) return !1;
+    if (E.str(e) || E.num(e) || E.boo(e)) return e === n;
+    const p = E.obj(e);
+    if (p && i === "reference") return e === n;
+    const _ = E.arr(e);
+    if (_ && o === "reference") return e === n;
+    if ((_ || p) && e === n) return !0;
+    let g;
+    for (g in e) if (!(g in n)) return !1;
+    if (p && o === "shallow" && i === "shallow") {
+      for (g in u ? n : e) if (!E.equ(e[g], n[g], {
+        strict: u,
+        objects: "reference"
+      })) return !1;
+    } else
+      for (g in u ? n : e) if (e[g] !== n[g]) return !1;
+    if (E.und(g)) {
+      if (_ && e.length === 0 && n.length === 0 || p && Object.keys(e).length === 0 && Object.keys(n).length === 0) return !0;
+      if (e !== n) return !1;
+    }
+    return !0;
+  }
+};
+function at(e) {
+  const n = {
+    nodes: {},
+    materials: {}
+  };
+  return e && e.traverse((o) => {
+    o.name && (n.nodes[o.name] = o), o.material && !n.materials[o.material.name] && (n.materials[o.material.name] = o.material);
+  }), n;
+}
+function lt(e) {
+  e.dispose && e.type !== "Scene" && e.dispose();
+  for (const n in e)
+    n.dispose == null || n.dispose(), delete e[n];
+}
+function I(e, n) {
+  const o = e;
+  return o.__r3f = {
+    type: "",
+    root: null,
+    previousAttach: null,
+    memoizedProps: {},
+    eventCount: 0,
+    handlers: {},
+    objects: [],
+    parent: null,
+    ...n
+  }, e;
+}
+function le(e, n) {
+  let o = e;
+  if (n.includes("-")) {
+    const i = n.split("-"), u = i.pop();
+    return o = i.reduce((p, _) => p[_], e), {
+      target: o,
+      key: u
+    };
+  } else return {
+    target: o,
+    key: n
+  };
+}
+const we = /-\d+$/;
+function te(e, n, o) {
+  if (E.str(o)) {
+    if (we.test(o)) {
+      const p = o.replace(we, ""), {
+        target: _,
+        key: g
+      } = le(e, p);
+      Array.isArray(_[g]) || (_[g] = []);
+    }
+    const {
+      target: i,
+      key: u
+    } = le(e, o);
+    n.__r3f.previousAttach = i[u], i[u] = n;
+  } else n.__r3f.previousAttach = o(e, n);
+}
+function be(e, n, o) {
+  var i, u;
+  if (E.str(o)) {
+    const {
+      target: p,
+      key: _
+    } = le(e, o), g = n.__r3f.previousAttach;
+    g === void 0 ? delete p[_] : p[_] = g;
+  } else (i = n.__r3f) == null || i.previousAttach == null || i.previousAttach(e, n);
+  (u = n.__r3f) == null || delete u.previousAttach;
+}
+function Re(e, {
+  children: n,
+  key: o,
+  ref: i,
+  ...u
+}, {
+  children: p,
+  key: _,
+  ref: g,
+  ...d
+} = {}, v = !1) {
+  const t = e.__r3f, r = Object.entries(u), f = [];
+  if (v) {
+    const c = Object.keys(d);
+    for (let w = 0; w < c.length; w++)
+      u.hasOwnProperty(c[w]) || r.unshift([c[w], xe + "remove"]);
+  }
+  r.forEach(([c, w]) => {
+    var h;
+    if ((h = e.__r3f) != null && h.primitive && c === "object" || E.equ(w, d[c])) return;
+    if (/^on(Pointer|Click|DoubleClick|ContextMenu|Wheel)/.test(c)) return f.push([c, w, !0, []]);
+    let s = [];
+    c.includes("-") && (s = c.split("-")), f.push([c, w, !1, s]);
+    for (const a in u) {
+      const m = u[a];
+      a.startsWith(`${c}-`) && f.push([a, m, !1, a.split("-")]);
+    }
+  });
+  const l = {
+    ...u
+  };
+  return t != null && t.memoizedProps && t != null && t.memoizedProps.args && (l.args = t.memoizedProps.args), t != null && t.memoizedProps && t != null && t.memoizedProps.attach && (l.attach = t.memoizedProps.attach), {
+    memoized: l,
+    changes: f
+  };
+}
+const ct = typeof process < "u" && process.env.NODE_ENV !== "production";
+function ne(e, n) {
+  var o;
+  const i = e.__r3f, u = i == null ? void 0 : i.root, p = u == null || u.getState == null ? void 0 : u.getState(), {
+    memoized: _,
+    changes: g
+  } = st(n) ? n : Re(e, n), d = i == null ? void 0 : i.eventCount;
+  e.__r3f && (e.__r3f.memoizedProps = _);
+  for (let f = 0; f < g.length; f++) {
+    let [l, c, w, h] = g[f];
+    if (ee(e)) {
+      const b = "srgb", C = "srgb-linear";
+      l === "encoding" ? (l = "colorSpace", c = c === 3001 ? b : C) : l === "outputEncoding" && (l = "outputColorSpace", c = c === 3001 ? b : C);
+    }
+    let s = e, a = s[l];
+    if (h.length && (a = h.reduce((m, b) => m[b], e), !(a && a.set))) {
+      const [m, ...b] = h.reverse();
+      s = b.reverse().reduce((C, S) => C[S], e), l = m;
+    }
+    if (c === xe + "remove")
+      if (s.constructor) {
+        let m = _e.get(s.constructor);
+        m || (m = new s.constructor(), _e.set(s.constructor, m)), c = m[l];
+      } else
+        c = 0;
+    if (w && i)
+      c ? i.handlers[l] = c : delete i.handlers[l], i.eventCount = Object.keys(i.handlers).length;
+    else if (a && a.set && (a.copy || a instanceof Z)) {
+      if (Array.isArray(c))
+        a.fromArray ? a.fromArray(c) : a.set(...c);
+      else if (a.copy && c && c.constructor && // Some environments may break strict identity checks by duplicating versions of three.js.
+      // Loosen to unminified names, ignoring descendents.
+      // https://github.com/pmndrs/react-three-fiber/issues/2856
+      // TODO: fix upstream and remove in v9
+      (ct ? a.constructor.name === c.constructor.name : a.constructor === c.constructor))
+        a.copy(c);
+      else if (c !== void 0) {
+        var v;
+        const m = (v = a) == null ? void 0 : v.isColor;
+        !m && a.setScalar ? a.setScalar(c) : a instanceof Z && c instanceof Z ? a.mask = c.mask : a.set(c), !Me() && p && !p.linear && m && a.convertSRGBToLinear();
+      }
+    } else {
+      var t;
+      if (s[l] = c, (t = s[l]) != null && t.isTexture && // sRGB textures must be RGBA8 since r137 https://github.com/mrdoob/three.js/pull/23129
+      s[l].format === Ke && s[l].type === Je && p) {
+        const m = s[l];
+        ee(m) && ee(p.gl) ? m.colorSpace = p.gl.outputColorSpace : m.encoding = p.gl.outputEncoding;
+      }
+    }
+    B(e);
+  }
+  if (i && i.parent && e.raycast && d !== i.eventCount) {
+    const f = Y(e).getState().internal, l = f.interaction.indexOf(e);
+    l > -1 && f.interaction.splice(l, 1), i.eventCount && f.interaction.push(e);
+  }
+  return !(g.length === 1 && g[0][0] === "onUpdate") && g.length && (o = e.__r3f) != null && o.parent && ce(e), e;
+}
+function B(e) {
+  var n, o;
+  const i = (n = e.__r3f) == null || (o = n.root) == null || o.getState == null ? void 0 : o.getState();
+  i && i.internal.frames === 0 && i.invalidate();
+}
+function ce(e) {
+  e.onUpdate == null || e.onUpdate(e);
+}
+function ft(e, n) {
+  e.manual || (Oe(e) ? (e.left = n.width / -2, e.right = n.width / 2, e.top = n.height / 2, e.bottom = n.height / -2) : e.aspect = n.width / n.height, e.updateProjectionMatrix(), e.updateMatrixWorld());
+}
+function W(e) {
+  return (e.eventObject || e.object).uuid + "/" + e.index + e.instanceId;
+}
+function ut() {
+  var e;
+  const n = typeof self < "u" && self || typeof window < "u" && window;
+  if (!n) return H.DefaultEventPriority;
+  switch ((e = n.event) == null ? void 0 : e.type) {
+    case "click":
+    case "contextmenu":
+    case "dblclick":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+      return H.DiscreteEventPriority;
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "pointerenter":
+    case "pointerleave":
+    case "wheel":
+      return H.ContinuousEventPriority;
+    default:
+      return H.DefaultEventPriority;
+  }
+}
+function Te(e, n, o, i) {
+  const u = o.get(n);
+  u && (o.delete(n), o.size === 0 && (e.delete(i), u.target.releasePointerCapture(i)));
+}
+function dt(e, n) {
+  const {
+    internal: o
+  } = e.getState();
+  o.interaction = o.interaction.filter((i) => i !== n), o.initialHits = o.initialHits.filter((i) => i !== n), o.hovered.forEach((i, u) => {
+    (i.eventObject === n || i.object === n) && o.hovered.delete(u);
+  }), o.capturedMap.forEach((i, u) => {
+    Te(o.capturedMap, n, i, u);
+  });
+}
+function pt(e) {
+  function n(d) {
+    const {
+      internal: v
+    } = e.getState(), t = d.offsetX - v.initialClick[0], r = d.offsetY - v.initialClick[1];
+    return Math.round(Math.sqrt(t * t + r * r));
+  }
+  function o(d) {
+    return d.filter((v) => ["Move", "Over", "Enter", "Out", "Leave"].some((t) => {
+      var r;
+      return (r = v.__r3f) == null ? void 0 : r.handlers["onPointer" + t];
+    }));
+  }
+  function i(d, v) {
+    const t = e.getState(), r = /* @__PURE__ */ new Set(), f = [], l = v ? v(t.internal.interaction) : t.internal.interaction;
+    for (let s = 0; s < l.length; s++) {
+      const a = G(l[s]);
+      a && (a.raycaster.camera = void 0);
+    }
+    t.previousRoot || t.events.compute == null || t.events.compute(d, t);
+    function c(s) {
+      const a = G(s);
+      if (!a || !a.events.enabled || a.raycaster.camera === null) return [];
+      if (a.raycaster.camera === void 0) {
+        var m;
+        a.events.compute == null || a.events.compute(d, a, (m = a.previousRoot) == null ? void 0 : m.getState()), a.raycaster.camera === void 0 && (a.raycaster.camera = null);
+      }
+      return a.raycaster.camera ? a.raycaster.intersectObject(s, !0) : [];
+    }
+    let w = l.flatMap(c).sort((s, a) => {
+      const m = G(s.object), b = G(a.object);
+      return !m || !b ? s.distance - a.distance : b.events.priority - m.events.priority || s.distance - a.distance;
+    }).filter((s) => {
+      const a = W(s);
+      return r.has(a) ? !1 : (r.add(a), !0);
+    });
+    t.events.filter && (w = t.events.filter(w, t));
+    for (const s of w) {
+      let a = s.object;
+      for (; a; ) {
+        var h;
+        (h = a.__r3f) != null && h.eventCount && f.push({
+          ...s,
+          eventObject: a
+        }), a = a.parent;
+      }
+    }
+    if ("pointerId" in d && t.internal.capturedMap.has(d.pointerId))
+      for (let s of t.internal.capturedMap.get(d.pointerId).values())
+        r.has(W(s.intersection)) || f.push(s.intersection);
+    return f;
+  }
+  function u(d, v, t, r) {
+    const f = e.getState();
+    if (d.length) {
+      const l = {
+        stopped: !1
+      };
+      for (const c of d) {
+        const w = G(c.object) || f, {
+          raycaster: h,
+          pointer: s,
+          camera: a,
+          internal: m
+        } = w, b = new X(s.x, s.y, 0).unproject(a), C = (x) => {
+          var y, P;
+          return (y = (P = m.capturedMap.get(x)) == null ? void 0 : P.has(c.eventObject)) != null ? y : !1;
+        }, S = (x) => {
+          const y = {
+            intersection: c,
+            target: v.target
+          };
+          m.capturedMap.has(x) ? m.capturedMap.get(x).set(c.eventObject, y) : m.capturedMap.set(x, /* @__PURE__ */ new Map([[c.eventObject, y]])), v.target.setPointerCapture(x);
+        }, M = (x) => {
+          const y = m.capturedMap.get(x);
+          y && Te(m.capturedMap, c.eventObject, y, x);
+        };
+        let j = {};
+        for (let x in v) {
+          let y = v[x];
+          typeof y != "function" && (j[x] = y);
+        }
+        let O = {
+          ...c,
+          ...j,
+          pointer: s,
+          intersections: d,
+          stopped: l.stopped,
+          delta: t,
+          unprojectedPoint: b,
+          ray: h.ray,
+          camera: a,
+          // Hijack stopPropagation, which just sets a flag
+          stopPropagation() {
+            const x = "pointerId" in v && m.capturedMap.get(v.pointerId);
+            if (
+              // ...if this pointer hasn't been captured
+              (!x || // ... or if the hit object is capturing the pointer
+              x.has(c.eventObject)) && (O.stopped = l.stopped = !0, m.hovered.size && Array.from(m.hovered.values()).find((y) => y.eventObject === c.eventObject))
+            ) {
+              const y = d.slice(0, d.indexOf(c));
+              p([...y, c]);
+            }
+          },
+          // there should be a distinction between target and currentTarget
+          target: {
+            hasPointerCapture: C,
+            setPointerCapture: S,
+            releasePointerCapture: M
+          },
+          currentTarget: {
+            hasPointerCapture: C,
+            setPointerCapture: S,
+            releasePointerCapture: M
+          },
+          nativeEvent: v
+        };
+        if (r(O), l.stopped === !0) break;
+      }
+    }
+    return d;
+  }
+  function p(d) {
+    const {
+      internal: v
+    } = e.getState();
+    for (const t of v.hovered.values())
+      if (!d.length || !d.find((r) => r.object === t.object && r.index === t.index && r.instanceId === t.instanceId)) {
+        const f = t.eventObject.__r3f, l = f == null ? void 0 : f.handlers;
+        if (v.hovered.delete(W(t)), f != null && f.eventCount) {
+          const c = {
+            ...t,
+            intersections: d
+          };
+          l.onPointerOut == null || l.onPointerOut(c), l.onPointerLeave == null || l.onPointerLeave(c);
+        }
+      }
+  }
+  function _(d, v) {
+    for (let t = 0; t < v.length; t++) {
+      const r = v[t].__r3f;
+      r == null || r.handlers.onPointerMissed == null || r.handlers.onPointerMissed(d);
+    }
+  }
+  function g(d) {
+    switch (d) {
+      case "onPointerLeave":
+      case "onPointerCancel":
+        return () => p([]);
+      case "onLostPointerCapture":
+        return (v) => {
+          const {
+            internal: t
+          } = e.getState();
+          "pointerId" in v && t.capturedMap.has(v.pointerId) && requestAnimationFrame(() => {
+            t.capturedMap.has(v.pointerId) && (t.capturedMap.delete(v.pointerId), p([]));
+          });
+        };
+    }
+    return function(t) {
+      const {
+        onPointerMissed: r,
+        internal: f
+      } = e.getState();
+      f.lastEvent.current = t;
+      const l = d === "onPointerMove", c = d === "onClick" || d === "onContextMenu" || d === "onDoubleClick", h = i(t, l ? o : void 0), s = c ? n(t) : 0;
+      d === "onPointerDown" && (f.initialClick = [t.offsetX, t.offsetY], f.initialHits = h.map((m) => m.eventObject)), c && !h.length && s <= 2 && (_(t, f.interaction), r && r(t)), l && p(h);
+      function a(m) {
+        const b = m.eventObject, C = b.__r3f, S = C == null ? void 0 : C.handlers;
+        if (C != null && C.eventCount)
+          if (l) {
+            if (S.onPointerOver || S.onPointerEnter || S.onPointerOut || S.onPointerLeave) {
+              const M = W(m), j = f.hovered.get(M);
+              j ? j.stopped && m.stopPropagation() : (f.hovered.set(M, m), S.onPointerOver == null || S.onPointerOver(m), S.onPointerEnter == null || S.onPointerEnter(m));
+            }
+            S.onPointerMove == null || S.onPointerMove(m);
+          } else {
+            const M = S[d];
+            M ? (!c || f.initialHits.includes(b)) && (_(t, f.interaction.filter((j) => !f.initialHits.includes(j))), M(m)) : c && f.initialHits.includes(b) && _(t, f.interaction.filter((j) => !f.initialHits.includes(j)));
+          }
+      }
+      u(h, t, s, a);
+    };
+  }
+  return {
+    handlePointer: g
+  };
+}
+const Ae = (e) => !!(e != null && e.render), ke = /* @__PURE__ */ D.createContext(null), vt = (e, n) => {
+  const o = Qe((g, d) => {
+    const v = new X(), t = new X(), r = new X();
+    function f(s = d().camera, a = t, m = d().size) {
+      const {
+        width: b,
+        height: C,
+        top: S,
+        left: M
+      } = m, j = b / C;
+      a.isVector3 ? r.copy(a) : r.set(...a);
+      const O = s.getWorldPosition(v).distanceTo(r);
+      if (Oe(s))
+        return {
+          width: b / s.zoom,
+          height: C / s.zoom,
+          top: S,
+          left: M,
+          factor: 1,
+          distance: O,
+          aspect: j
+        };
+      {
+        const x = s.fov * Math.PI / 180, y = 2 * Math.tan(x / 2) * O, P = y * (b / C);
+        return {
+          width: P,
+          height: y,
+          top: S,
+          left: M,
+          factor: b / P,
+          distance: O,
+          aspect: j
+        };
+      }
+    }
+    let l;
+    const c = (s) => g((a) => ({
+      performance: {
+        ...a.performance,
+        current: s
+      }
+    })), w = new Xe();
+    return {
+      set: g,
+      get: d,
+      // Mock objects that have to be configured
+      gl: null,
+      camera: null,
+      raycaster: null,
+      events: {
+        priority: 1,
+        enabled: !0,
+        connected: !1
+      },
+      xr: null,
+      scene: null,
+      invalidate: (s = 1) => e(d(), s),
+      advance: (s, a) => n(s, a, d()),
+      legacy: !1,
+      linear: !1,
+      flat: !1,
+      controls: null,
+      clock: new Ye(),
+      pointer: w,
+      mouse: w,
+      frameloop: "always",
+      onPointerMissed: void 0,
+      performance: {
+        current: 1,
+        min: 0.5,
+        max: 1,
+        debounce: 200,
+        regress: () => {
+          const s = d();
+          l && clearTimeout(l), s.performance.current !== s.performance.min && c(s.performance.min), l = setTimeout(() => c(d().performance.max), s.performance.debounce);
+        }
+      },
+      size: {
+        width: 0,
+        height: 0,
+        top: 0,
+        left: 0,
+        updateStyle: !1
+      },
+      viewport: {
+        initialDpr: 0,
+        dpr: 0,
+        width: 0,
+        height: 0,
+        top: 0,
+        left: 0,
+        aspect: 0,
+        distance: 0,
+        factor: 0,
+        getCurrentViewport: f
+      },
+      setEvents: (s) => g((a) => ({
+        ...a,
+        events: {
+          ...a.events,
+          ...s
+        }
+      })),
+      setSize: (s, a, m, b, C) => {
+        const S = d().camera, M = {
+          width: s,
+          height: a,
+          top: b || 0,
+          left: C || 0,
+          updateStyle: m
+        };
+        g((j) => ({
+          size: M,
+          viewport: {
+            ...j.viewport,
+            ...f(S, t, M)
+          }
+        }));
+      },
+      setDpr: (s) => g((a) => {
+        const m = je(s);
+        return {
+          viewport: {
+            ...a.viewport,
+            dpr: m,
+            initialDpr: a.viewport.initialDpr || m
+          }
+        };
+      }),
+      setFrameloop: (s = "always") => {
+        const a = d().clock;
+        a.stop(), a.elapsedTime = 0, s !== "never" && (a.start(), a.elapsedTime = 0), g(() => ({
+          frameloop: s
+        }));
+      },
+      previousRoot: void 0,
+      internal: {
+        active: !1,
+        priority: 0,
+        frames: 0,
+        lastEvent: /* @__PURE__ */ D.createRef(),
+        interaction: [],
+        hovered: /* @__PURE__ */ new Map(),
+        subscribers: [],
+        initialClick: [0, 0],
+        initialHits: [],
+        capturedMap: /* @__PURE__ */ new Map(),
+        subscribe: (s, a, m) => {
+          const b = d().internal;
+          return b.priority = b.priority + (a > 0 ? 1 : 0), b.subscribers.push({
+            ref: s,
+            priority: a,
+            store: m
+          }), b.subscribers = b.subscribers.sort((C, S) => C.priority - S.priority), () => {
+            const C = d().internal;
+            C != null && C.subscribers && (C.priority = C.priority - (a > 0 ? 1 : 0), C.subscribers = C.subscribers.filter((S) => S.ref !== s));
+          };
+        }
+      }
+    };
+  }), i = o.getState();
+  let u = i.size, p = i.viewport.dpr, _ = i.camera;
+  return o.subscribe(() => {
+    const {
+      camera: g,
+      size: d,
+      viewport: v,
+      gl: t,
+      set: r
+    } = o.getState();
+    if (d.width !== u.width || d.height !== u.height || v.dpr !== p) {
+      var f;
+      u = d, p = v.dpr, ft(g, d), t.setPixelRatio(v.dpr);
+      const l = (f = d.updateStyle) != null ? f : typeof HTMLCanvasElement < "u" && t.domElement instanceof HTMLCanvasElement;
+      t.setSize(d.width, d.height, l);
+    }
+    g !== _ && (_ = g, r((l) => ({
+      viewport: {
+        ...l.viewport,
+        ...l.viewport.getCurrentViewport(g)
+      }
+    })));
+  }), o.subscribe((g) => e(g)), o;
+};
+let $, mt = /* @__PURE__ */ new Set(), ht = /* @__PURE__ */ new Set(), gt = /* @__PURE__ */ new Set();
+function re(e, n) {
+  if (e.size)
+    for (const {
+      callback: o
+    } of e.values())
+      o(n);
+}
+function U(e, n) {
+  switch (e) {
+    case "before":
+      return re(mt, n);
+    case "after":
+      return re(ht, n);
+    case "tail":
+      return re(gt, n);
+  }
+}
+let oe, ie;
+function se(e, n, o) {
+  let i = n.clock.getDelta();
+  for (n.frameloop === "never" && typeof e == "number" && (i = e - n.clock.elapsedTime, n.clock.oldTime = n.clock.elapsedTime, n.clock.elapsedTime = e), oe = n.internal.subscribers, $ = 0; $ < oe.length; $++)
+    ie = oe[$], ie.ref.current(ie.store.getState(), i, o);
+  return !n.internal.priority && n.gl.render && n.gl.render(n.scene, n.camera), n.internal.frames = Math.max(0, n.internal.frames - 1), n.frameloop === "always" ? 1 : n.internal.frames;
+}
+function yt(e) {
+  let n = !1, o = !1, i, u, p;
+  function _(v) {
+    u = requestAnimationFrame(_), n = !0, i = 0, U("before", v), o = !0;
+    for (const r of e.values()) {
+      var t;
+      p = r.store.getState(), p.internal.active && (p.frameloop === "always" || p.internal.frames > 0) && !((t = p.gl.xr) != null && t.isPresenting) && (i += se(v, p));
+    }
+    if (o = !1, U("after", v), i === 0)
+      return U("tail", v), n = !1, cancelAnimationFrame(u);
+  }
+  function g(v, t = 1) {
+    var r;
+    if (!v) return e.forEach((f) => g(f.store.getState(), t));
+    (r = v.gl.xr) != null && r.isPresenting || !v.internal.active || v.frameloop === "never" || (t > 1 ? v.internal.frames = Math.min(60, v.internal.frames + t) : o ? v.internal.frames = 2 : v.internal.frames = 1, n || (n = !0, requestAnimationFrame(_)));
+  }
+  function d(v, t = !0, r, f) {
+    if (t && U("before", v), r) se(v, r, f);
+    else for (const l of e.values()) se(v, l.store.getState());
+    t && U("after", v);
+  }
+  return {
+    loop: _,
+    invalidate: g,
+    advance: d
+  };
+}
+function _t() {
+  const e = D.useContext(ke);
+  if (!e) throw new Error("R3F: Hooks can only be used within the Canvas component!");
+  return e;
+}
+function Dt(e, n = 0) {
+  const o = _t(), i = o.getState().internal.subscribe, u = ot(e);
+  return J(() => i(u, n, o), [n, i, o]), null;
+}
+const Ce = /* @__PURE__ */ new WeakMap();
+function De(e, n) {
+  return function(o, ...i) {
+    let u = Ce.get(o);
+    return u || (u = new o(), Ce.set(o, u)), e && e(u), Promise.all(i.map((p) => new Promise((_, g) => u.load(p, (d) => {
+      d.scene && Object.assign(d, at(d.scene)), _(d);
+    }, n, (d) => g(new Error(`Could not load ${p}: ${d == null ? void 0 : d.message}`))))));
+  };
+}
+function Le(e, n, o, i) {
+  const u = Array.isArray(n) ? n : [n], p = Ze(De(o, i), [e, ...u], {
+    equal: E.equ
+  });
+  return Array.isArray(n) ? p : p[0];
+}
+Le.preload = function(e, n, o) {
+  const i = Array.isArray(n) ? n : [n];
+  return et(De(o), [e, ...i]);
+};
+Le.clear = function(e, n) {
+  const o = Array.isArray(n) ? n : [n];
+  return tt([e, ...o]);
+};
+const N = /* @__PURE__ */ new Map(), {
+  invalidate: Se,
+  advance: Ee
+} = yt(N), {
+  reconciler: K,
+  applyProps: z
+} = rt(N, ut), F = {
+  objects: "shallow",
+  strict: !1
+}, wt = (e, n) => {
+  const o = typeof e == "function" ? e(n) : e;
+  return Ae(o) ? o : new We({
+    powerPreference: "high-performance",
+    canvas: n,
+    antialias: !0,
+    alpha: !0,
+    ...e
+  });
+};
+function bt(e, n) {
+  const o = typeof HTMLCanvasElement < "u" && e instanceof HTMLCanvasElement;
+  if (n) {
+    const {
+      width: i,
+      height: u,
+      top: p,
+      left: _,
+      updateStyle: g = o
+    } = n;
+    return {
+      width: i,
+      height: u,
+      top: p,
+      left: _,
+      updateStyle: g
+    };
+  } else if (typeof HTMLCanvasElement < "u" && e instanceof HTMLCanvasElement && e.parentElement) {
+    const {
+      width: i,
+      height: u,
+      top: p,
+      left: _
+    } = e.parentElement.getBoundingClientRect();
+    return {
+      width: i,
+      height: u,
+      top: p,
+      left: _,
+      updateStyle: o
+    };
+  } else if (typeof OffscreenCanvas < "u" && e instanceof OffscreenCanvas)
+    return {
+      width: e.width,
+      height: e.height,
+      top: 0,
+      left: 0,
+      updateStyle: o
+    };
+  return {
+    width: 0,
+    height: 0,
+    top: 0,
+    left: 0
+  };
+}
+function Lt(e) {
+  const n = N.get(e), o = n == null ? void 0 : n.fiber, i = n == null ? void 0 : n.store;
+  n && console.warn("R3F.createRoot should only be called once!");
+  const u = typeof reportError == "function" ? (
+    // In modern browsers, reportError will dispatch an error event,
+    // emulating an uncaught JavaScript error.
+    reportError
+  ) : (
+    // In older browsers and test environments, fallback to console.error.
+    console.error
+  ), p = i || vt(Se, Ee), _ = o || K.createContainer(p, H.ConcurrentRoot, null, !1, null, "", u, null);
+  n || N.set(e, {
+    fiber: _,
+    store: p
+  });
+  let g, d = !1, v;
+  return {
+    configure(t = {}) {
+      let {
+        gl: r,
+        size: f,
+        scene: l,
+        events: c,
+        onCreated: w,
+        shadows: h = !1,
+        linear: s = !1,
+        flat: a = !1,
+        legacy: m = !1,
+        orthographic: b = !1,
+        frameloop: C = "always",
+        dpr: S = [1, 2],
+        performance: M,
+        raycaster: j,
+        camera: O,
+        onPointerMissed: x
+      } = t, y = p.getState(), P = y.gl;
+      y.gl || y.set({
+        gl: P = wt(r, e)
+      });
+      let k = y.raycaster;
+      k || y.set({
+        raycaster: k = new Fe()
+      });
+      const {
+        params: ue,
+        ...de
+      } = j || {};
+      if (E.equ(de, k, F) || z(k, {
+        ...de
+      }), E.equ(ue, k.params, F) || z(k, {
+        params: {
+          ...k.params,
+          ...ue
+        }
+      }), !y.camera || y.camera === v && !E.equ(v, O, F)) {
+        v = O;
+        const T = O instanceof $e, R = T ? O : b ? new Ie(0, 0, 0, 0, 0.1, 1e3) : new Be(75, 0, 0.1, 1e3);
+        T || (R.position.z = 5, O && (z(R, O), ("aspect" in O || "left" in O || "right" in O || "bottom" in O || "top" in O) && (R.manual = !0, R.updateProjectionMatrix())), !y.camera && !(O != null && O.rotation) && R.lookAt(0, 0, 0)), y.set({
+          camera: R
+        }), k.camera = R;
+      }
+      if (!y.scene) {
+        let T;
+        l != null && l.isScene ? T = l : (T = new He(), l && z(T, l)), y.set({
+          scene: I(T)
+        });
+      }
+      if (!y.xr) {
+        var pe;
+        const T = (A, ze) => {
+          const me = p.getState();
+          me.frameloop !== "never" && Ee(A, !0, me, ze);
+        }, R = () => {
+          const A = p.getState();
+          A.gl.xr.enabled = A.gl.xr.isPresenting, A.gl.xr.setAnimationLoop(A.gl.xr.isPresenting ? T : null), A.gl.xr.isPresenting || Se(A);
+        }, V = {
+          connect() {
+            const A = p.getState().gl;
+            A.xr.addEventListener("sessionstart", R), A.xr.addEventListener("sessionend", R);
+          },
+          disconnect() {
+            const A = p.getState().gl;
+            A.xr.removeEventListener("sessionstart", R), A.xr.removeEventListener("sessionend", R);
+          }
+        };
+        typeof ((pe = P.xr) == null ? void 0 : pe.addEventListener) == "function" && V.connect(), y.set({
+          xr: V
+        });
+      }
+      if (P.shadowMap) {
+        const T = P.shadowMap.enabled, R = P.shadowMap.type;
+        if (P.shadowMap.enabled = !!h, E.boo(h))
+          P.shadowMap.type = Q;
+        else if (E.str(h)) {
+          var ve;
+          const V = {
+            basic: Ge,
+            percentage: qe,
+            soft: Q,
+            variance: Ne
+          };
+          P.shadowMap.type = (ve = V[h]) != null ? ve : Q;
+        } else E.obj(h) && Object.assign(P.shadowMap, h);
+        (T !== P.shadowMap.enabled || R !== P.shadowMap.type) && (P.shadowMap.needsUpdate = !0);
+      }
+      const q = Me();
+      q && ("enabled" in q ? q.enabled = !m : "legacyMode" in q && (q.legacyMode = m)), d || z(P, {
+        outputEncoding: s ? 3e3 : 3001,
+        toneMapping: a ? Ue : Ve
+      }), y.legacy !== m && y.set(() => ({
+        legacy: m
+      })), y.linear !== s && y.set(() => ({
+        linear: s
+      })), y.flat !== a && y.set(() => ({
+        flat: a
+      })), r && !E.fun(r) && !Ae(r) && !E.equ(r, P, F) && z(P, r), c && !y.events.handlers && y.set({
+        events: c(p)
+      });
+      const L = bt(e, f);
+      return E.equ(L, y.size, F) || y.setSize(L.width, L.height, L.updateStyle, L.top, L.left), S && y.viewport.dpr !== je(S) && y.setDpr(S), y.frameloop !== C && y.setFrameloop(C), y.onPointerMissed || y.set({
+        onPointerMissed: x
+      }), M && !E.equ(M, y.performance, F) && y.set((T) => ({
+        performance: {
+          ...T.performance,
+          ...M
+        }
+      })), g = w, d = !0, this;
+    },
+    render(t) {
+      return d || this.configure(), K.updateContainer(/* @__PURE__ */ Pe(Ct, {
+        store: p,
+        children: t,
+        onCreated: g,
+        rootElement: e
+      }), _, null, () => {
+      }), p;
+    },
+    unmount() {
+      St(e);
+    }
+  };
+}
+function Ct({
+  store: e,
+  children: n,
+  onCreated: o,
+  rootElement: i
+}) {
+  return J(() => {
+    const u = e.getState();
+    u.set((p) => ({
+      internal: {
+        ...p.internal,
+        active: !0
+      }
+    })), o && o(u), e.getState().events.connected || u.events.connect == null || u.events.connect(i);
+  }, []), /* @__PURE__ */ Pe(ke.Provider, {
+    value: e,
+    children: n
+  });
+}
+function St(e, n) {
+  const o = N.get(e), i = o == null ? void 0 : o.fiber;
+  if (i) {
+    const u = o == null ? void 0 : o.store.getState();
+    u && (u.internal.active = !1), K.updateContainer(null, i, null, () => {
+      u && setTimeout(() => {
+        try {
+          var p, _, g, d;
+          u.events.disconnect == null || u.events.disconnect(), (p = u.gl) == null || (_ = p.renderLists) == null || _.dispose == null || _.dispose(), (g = u.gl) == null || g.forceContextLoss == null || g.forceContextLoss(), (d = u.gl) != null && d.xr && u.xr.disconnect(), lt(u), N.delete(e);
+        } catch {
+        }
+      }, 500);
+    });
+  }
+}
+K.injectIntoDevTools({
+  bundleType: process.env.NODE_ENV === "production" ? 0 : 1,
+  rendererPackageName: "@react-three/fiber",
+  version: D.version
+});
+const ae = {
+  onClick: ["click", !1],
+  onContextMenu: ["contextmenu", !1],
+  onDoubleClick: ["dblclick", !1],
+  onWheel: ["wheel", !0],
+  onPointerDown: ["pointerdown", !0],
+  onPointerUp: ["pointerup", !0],
+  onPointerLeave: ["pointerleave", !0],
+  onPointerMove: ["pointermove", !0],
+  onPointerCancel: ["pointercancel", !0],
+  onLostPointerCapture: ["lostpointercapture", !0]
+};
+function zt(e) {
+  const {
+    handlePointer: n
+  } = pt(e);
+  return {
+    priority: 1,
+    enabled: !0,
+    compute(o, i, u) {
+      i.pointer.set(o.offsetX / i.size.width * 2 - 1, -(o.offsetY / i.size.height) * 2 + 1), i.raycaster.setFromCamera(i.pointer, i.camera);
+    },
+    connected: void 0,
+    handlers: Object.keys(ae).reduce((o, i) => ({
+      ...o,
+      [i]: n(i)
+    }), {}),
+    update: () => {
+      var o;
+      const {
+        events: i,
+        internal: u
+      } = e.getState();
+      (o = u.lastEvent) != null && o.current && i.handlers && i.handlers.onPointerMove(u.lastEvent.current);
+    },
+    connect: (o) => {
+      var i;
+      const {
+        set: u,
+        events: p
+      } = e.getState();
+      p.disconnect == null || p.disconnect(), u((_) => ({
+        events: {
+          ..._.events,
+          connected: o
+        }
+      })), Object.entries((i = p.handlers) != null ? i : []).forEach(([_, g]) => {
+        const [d, v] = ae[_];
+        o.addEventListener(d, g, {
+          passive: v
+        });
+      });
+    },
+    disconnect: () => {
+      const {
+        set: o,
+        events: i
+      } = e.getState();
+      if (i.connected) {
+        var u;
+        Object.entries((u = i.handlers) != null ? u : []).forEach(([p, _]) => {
+          if (i && i.connected instanceof HTMLElement) {
+            const [g] = ae[p];
+            i.connected.removeEventListener(g, _);
+          }
+        }), o((p) => ({
+          events: {
+            ...p.events,
+            connected: void 0
+          }
+        }));
+      }
+    }
+  };
+}
+export {
+  kt as B,
+  _t as C,
+  it as E,
+  Dt as F,
+  Le as H,
+  J as a,
+  Lt as b,
+  zt as c,
+  St as d,
+  Tt as e,
+  pt as f,
+  ke as g,
+  At as i,
+  K as j,
+  z as k,
+  lt as l,
+  Se as m,
+  Ee as n,
+  U as s,
+  ot as u,
+  G as w,
+  at as y,
+  N as z
+};