@vincentt-xr/sdk 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/renderPasses-CjgG_6kQ.js

@@ -0,0 +1,1500 @@
+import { u as Ee, S as ze, a as Pe, D as Re } from "./index-CTHeBQOs.js";
+import { useThree as xe, useFrame as Oe } from "@react-three/fiber";
+import { useRef as W, useState as De, useCallback as U, useEffect as k, useMemo as G, createElement as Le } from "react";
+import * as ce from "three";
+import { Vector2 as K, Vector3 as z, Box3 as Ae, Matrix4 as B, Quaternion as Y, Euler as H, MathUtils as L, Color as Ce } from "three";
+import { e as Fe } from "./index-JygePOwo.js";
+import { D as _e } from "./index-UC0Ux38E.js";
+import { w as Ie, x as je, M as We, a as Ge, A as Ne } from "./FaceMeshRenderer-6t8OsQhK.js";
+import { jsxs as O, jsx as u } from "react/jsx-runtime";
+import { Line as Ue } from "@react-three/drei";
+const he = {
+  move: "grab",
+  pivot: "all-scroll",
+  rotateTopLeft: "alias",
+  rotateTopRight: "alias",
+  rotateBottomLeft: "alias",
+  rotateBottomRight: "alias",
+  top: "ns-resize",
+  bottom: "ns-resize",
+  left: "ew-resize",
+  right: "ew-resize",
+  topLeft: "nwse-resize",
+  bottomRight: "nwse-resize",
+  topRight: "nesw-resize",
+  bottomLeft: "nesw-resize"
+}, ke = ({
+  color: e = "#22d3ee",
+  controlScale: t = [1, 1, 1],
+  handleColor: o = "#ffffff",
+  onHandlePointerDown: n,
+  opacity: i = 0.9,
+  pivot: r = [0.5, 0.5],
+  pivotScale: a = t,
+  renderOrder: s,
+  showSideHandles: l = !0,
+  thickness: d = 4e-3
+}) => {
+  const f = /* @__PURE__ */ u(
+    "meshBasicMaterial",
+    {
+      color: e,
+      transparent: !0,
+      opacity: i,
+      depthTest: !1,
+      depthWrite: !1,
+      toneMapped: !1
+    }
+  ), y = /* @__PURE__ */ u(
+    "meshBasicMaterial",
+    {
+      color: o,
+      transparent: !0,
+      opacity: 1,
+      depthTest: !1,
+      depthWrite: !1,
+      toneMapped: !1
+    }
+  ), w = Math.max(d * 7, 0.028), b = Math.max(d * 7, 0.03), M = Math.max(d * 8, 0.032), h = 0.04, c = 0.06, x = 0.08, g = 0.1, p = s ?? 0, C = [
+    ["topLeft", -0.5, 0.5],
+    ["topRight", 0.5, 0.5],
+    ["bottomLeft", -0.5, -0.5],
+    ["bottomRight", 0.5, -0.5],
+    ...l ? [
+      ["top", 0, 0.5],
+      ["bottom", 0, -0.5],
+      ["left", -0.5, 0],
+      ["right", 0.5, 0]
+    ] : []
+  ], E = [
+    ["rotateTopLeft", -0.56, 0.56, 0],
+    ["rotateTopRight", 0.56, 0.56, -Math.PI / 2],
+    ["rotateBottomRight", 0.56, -0.56, Math.PI],
+    ["rotateBottomLeft", -0.56, -0.56, Math.PI / 2]
+  ], S = (m) => n ? (R) => {
+    R.stopPropagation(), document.body.style.cursor = m === "move" ? "grabbing" : he[m], n(m, R);
+  } : void 0, v = (m) => {
+    n && (document.body.style.cursor = he[m]);
+  }, P = () => {
+    n && (document.body.style.cursor = "");
+  }, T = [r[0] - 0.5, r[1] - 0.5, g];
+  return /* @__PURE__ */ O("group", { renderOrder: p, children: [
+    /* @__PURE__ */ O("mesh", { position: [0, 0.5, h], scale: [1, d, 1], renderOrder: p, children: [
+      /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+      f
+    ] }),
+    /* @__PURE__ */ O("mesh", { position: [0, -0.5, h], scale: [1, d, 1], renderOrder: p, children: [
+      /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+      f
+    ] }),
+    /* @__PURE__ */ O("mesh", { position: [-0.5, 0, h], scale: [d, 1, 1], renderOrder: p, children: [
+      /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+      f
+    ] }),
+    /* @__PURE__ */ O("mesh", { position: [0.5, 0, h], scale: [d, 1, 1], renderOrder: p, children: [
+      /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+      f
+    ] }),
+    /* @__PURE__ */ O(
+      "mesh",
+      {
+        position: [0, 0, c],
+        renderOrder: p + 1,
+        onPointerDown: S("move"),
+        onPointerOver: () => v("move"),
+        onPointerOut: P,
+        children: [
+          /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+          /* @__PURE__ */ u("meshBasicMaterial", { transparent: !0, opacity: 0, depthTest: !1, depthWrite: !1 })
+        ]
+      }
+    ),
+    C.map(([m, R, F]) => /* @__PURE__ */ O(
+      "mesh",
+      {
+        position: [R, F, x],
+        scale: [w * t[0], w * t[1], t[2]],
+        renderOrder: p + 2,
+        onPointerDown: S(m),
+        onPointerOver: () => v(m),
+        onPointerOut: P,
+        children: [
+          /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+          y
+        ]
+      },
+      m
+    )),
+    E.map(([m, R, F, V]) => /* @__PURE__ */ u(
+      "group",
+      {
+        position: [R, F, x + 0.01],
+        rotation: [0, 0, V],
+        scale: [M * t[0], M * t[1], t[2]],
+        renderOrder: p + 3,
+        onPointerDown: S(m),
+        onPointerOver: () => v(m),
+        onPointerOut: P,
+        children: /* @__PURE__ */ O("mesh", { renderOrder: p + 3, children: [
+          /* @__PURE__ */ u("planeGeometry", { args: [1.9, 1.9] }),
+          /* @__PURE__ */ u("meshBasicMaterial", { transparent: !0, opacity: 0, depthTest: !1, depthWrite: !1 })
+        ] })
+      },
+      m
+    )),
+    /* @__PURE__ */ u(
+      "group",
+      {
+        position: T,
+        scale: [b * a[0], b * a[1], a[2]],
+        renderOrder: p + 5,
+        onPointerDown: S("pivot"),
+        onPointerOver: () => v("pivot"),
+        onPointerOut: P,
+        children: /* @__PURE__ */ O("group", { rotation: [0, 0, Math.PI / 4], children: [
+          /* @__PURE__ */ O("mesh", { scale: [1.8, 1.8, 1], renderOrder: p + 5, children: [
+            /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+            /* @__PURE__ */ u("meshBasicMaterial", { transparent: !0, opacity: 0, depthTest: !1, depthWrite: !1 })
+          ] }),
+          /* @__PURE__ */ O("mesh", { position: [0, 0, 2e-3], renderOrder: p + 6, children: [
+            /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+            y
+          ] }),
+          /* @__PURE__ */ O("mesh", { scale: [0.62, 0.62, 1], position: [0, 0, 4e-3], renderOrder: p + 7, children: [
+            /* @__PURE__ */ u("planeGeometry", { args: [1, 1] }),
+            /* @__PURE__ */ u(
+              "meshBasicMaterial",
+              {
+                color: "#111827",
+                transparent: !0,
+                opacity: 1,
+                depthTest: !1,
+                depthWrite: !1,
+                toneMapped: !1
+              }
+            )
+          ] })
+        ] })
+      }
+    )
+  ] });
+}, A = {
+  width: 720,
+  height: 1280
+}, q = 32, Xe = 0.5, j = {
+  enabled: !0,
+  position: { x: 0, y: 0 },
+  size: { width: 680, height: 1230 },
+  pivot: [0.5, 0.5],
+  rotation: 0,
+  scale2D: { x: 1, y: 1 },
+  referencePixelsPerUnit: q,
+  renderOrder: 999,
+  overlay: !0,
+  visible: !0,
+  showTransformGuides: !1
+}, Be = Math.PI / 180, ue = (e, t) => t <= 0 ? e : Math.round(e / t) * t, pe = ({
+  transform: e,
+  parentSize: t,
+  root: o = A,
+  snapIncrement: n = Xe
+}) => {
+  const r = Math.min(t.width / o.width, t.height / o.height) * (q / e.referencePixelsPerUnit), a = e.size.width * e.scale2D.x * r, s = e.size.height * e.scale2D.y * r, l = ue(e.position.x, n) * r, d = ue(e.position.y, n) * r, f = (e.pivot[0] - 0.5) * a, y = (e.pivot[1] - 0.5) * s;
+  return {
+    center: [l - f, d - y, 0],
+    size: [a, s, 1],
+    rotation: [0, 0, e.rotation * Be],
+    pivotOffset: [f / Math.max(a, 1e-6), y / Math.max(s, 1e-6), 0],
+    aspect: a > 0 && s > 0 ? Math.abs(a / s) : 1
+  };
+}, Ye = (e) => ({
+  ...j,
+  ...e,
+  position: { ...j.position, ...e == null ? void 0 : e.position },
+  size: { ...j.size, ...e == null ? void 0 : e.size },
+  scale2D: { ...j.scale2D, ...e == null ? void 0 : e.scale2D }
+}), _ = (e) => Math.round(e * 2) / 2, me = (e) => Math.min(1, Math.max(0, e)), te = {
+  move: "grab",
+  pivot: "all-scroll",
+  rotateTopLeft: "alias",
+  rotateTopRight: "alias",
+  rotateBottomLeft: "alias",
+  rotateBottomRight: "alias",
+  top: "ns-resize",
+  bottom: "ns-resize",
+  left: "ew-resize",
+  right: "ew-resize",
+  topLeft: "nwse-resize",
+  bottomRight: "nwse-resize",
+  topRight: "nesw-resize",
+  bottomLeft: "nesw-resize"
+}, $e = [
+  ["topLeft", 0, 0],
+  ["top", 0.5, 0],
+  ["topRight", 1, 0],
+  ["right", 1, 0.5],
+  ["bottomRight", 1, 1],
+  ["bottom", 0.5, 1],
+  ["bottomLeft", 0, 1],
+  ["left", 0, 0.5]
+], He = [
+  ["rotateTopLeft", -0.03, -0.03],
+  ["rotateTopRight", 1.03, -0.03],
+  ["rotateBottomRight", 1.03, 1.03],
+  ["rotateBottomLeft", -0.03, 1.03]
+], qe = (e, t) => {
+  const o = pe({
+    transform: t,
+    parentSize: { width: e.width, height: e.height }
+  }), n = Math.min(
+    e.width / A.width,
+    e.height / A.height
+  ) * (q / Math.max(t.referencePixelsPerUnit, 1e-6)) || 1, i = A.width * n, r = A.height * n, a = e.left + (e.width - i) / 2, s = e.top + (e.height - r) / 2, l = a + i / 2, d = s + r / 2, f = o.size[0], y = o.size[1], w = l + o.center[0], b = d - o.center[1];
+  return {
+    centerX: w,
+    centerY: b,
+    height: y,
+    left: w - f / 2,
+    scale: n,
+    top: b - y / 2,
+    width: f
+  };
+}, Ve = (e, t, o, n) => {
+  const i = A.width * n, r = A.height * n, a = o.left + (o.width - i) / 2, s = o.top + (o.height - r) / 2;
+  return {
+    x: (e - (a + i / 2)) / n,
+    y: (s + r / 2 - t) / n
+  };
+}, Ke = ({
+  color: e = "#38bdf8",
+  handleColor: t = "#ffffff",
+  onChange: o,
+  transform: n
+}) => {
+  const i = W(o);
+  i.current = o;
+  const { gl: r } = xe(), [a, s] = De(null), l = W(null), d = W(null), f = U(() => {
+    s(r.domElement.getBoundingClientRect());
+  }, [r.domElement]);
+  k(() => (f(), window.addEventListener("resize", f), window.addEventListener("scroll", f, !0), () => {
+    window.removeEventListener("resize", f), window.removeEventListener("scroll", f, !0);
+  }), [f]);
+  const y = G(
+    () => a ? qe(a, n) : null,
+    [a, n]
+  ), w = U((h) => {
+    const c = l.current, x = i.current;
+    if (!c || !x) return;
+    const g = (h.clientX - c.startX) / c.scale, p = -(h.clientY - c.startY) / c.scale, C = {
+      x: c.startPointerDesign.x + g,
+      y: c.startPointerDesign.y + p
+    }, E = {
+      ...c.startTransform,
+      position: { ...c.startTransform.position },
+      size: { ...c.startTransform.size },
+      pivot: [...c.startTransform.pivot]
+    };
+    if (c.handle === "move")
+      E.position = {
+        x: _(c.startTransform.position.x + g),
+        y: _(c.startTransform.position.y + p)
+      };
+    else if (c.handle === "pivot") {
+      const S = Math.max(
+        1,
+        c.startTransform.size.width * c.startTransform.scale2D.x
+      ), v = Math.max(
+        1,
+        c.startTransform.size.height * c.startTransform.scale2D.y
+      ), P = me(c.startTransform.pivot[0] + g / S), T = me(c.startTransform.pivot[1] + p / v);
+      E.pivot = [_(P * 1e3) / 1e3, _(T * 1e3) / 1e3], E.position = {
+        x: _(
+          c.startTransform.position.x + (E.pivot[0] - c.startTransform.pivot[0]) * S
+        ),
+        y: _(
+          c.startTransform.position.y + (E.pivot[1] - c.startTransform.pivot[1]) * v
+        )
+      };
+    } else if (c.handle.startsWith("rotate")) {
+      const S = Math.atan2(
+        c.startPointerDesign.y - c.startTransform.position.y,
+        c.startPointerDesign.x - c.startTransform.position.x
+      ), v = Math.atan2(
+        C.y - c.startTransform.position.y,
+        C.x - c.startTransform.position.x
+      );
+      E.rotation = _(
+        c.startTransform.rotation + (v - S) * 180 / Math.PI
+      );
+    } else {
+      const S = c.handle === "left" || c.handle.endsWith("Left"), v = c.handle === "right" || c.handle.endsWith("Right"), P = c.handle === "top" || c.handle.startsWith("top"), T = c.handle === "bottom" || c.handle.startsWith("bottom"), m = v ? g * 2 : S ? -g * 2 : 0, R = P ? p * 2 : T ? -p * 2 : 0;
+      E.size = {
+        width: Math.max(1, _(c.startTransform.size.width + m)),
+        height: Math.max(1, _(c.startTransform.size.height + R))
+      };
+    }
+    x(E);
+  }, []), b = U(() => {
+    l.current = null, document.body.style.cursor = "", window.removeEventListener("pointermove", w), window.removeEventListener("pointerup", b);
+  }, [w]);
+  k(() => b, [b]);
+  const M = U(
+    (h, c) => {
+      !a || !y || !o || (c.preventDefault(), document.body.style.cursor = h === "move" ? "grabbing" : te[h], l.current = {
+        handle: h,
+        startX: c.clientX,
+        startY: c.clientY,
+        startPointerDesign: Ve(c.clientX, c.clientY, a, y.scale),
+        startTransform: n,
+        scale: y.scale
+      }, window.addEventListener("pointermove", w), window.addEventListener("pointerup", b));
+    },
+    [a, y, o, b, n, w]
+  );
+  return k(() => {
+    if (typeof document > "u") return;
+    const h = document.createElement("div");
+    return document.body.appendChild(h), d.current = h, () => {
+      h.remove(), d.current = null;
+    };
+  }, []), k(() => {
+    const h = d.current;
+    if (!h || (h.replaceChildren(), !y))
+      return;
+    const c = 12, x = 12, g = document.createElement("div");
+    Object.assign(g.style, {
+      position: "fixed",
+      inset: "0",
+      zIndex: "19999",
+      pointerEvents: "none"
+    });
+    const p = document.createElement("div");
+    Object.assign(p.style, {
+      position: "absolute",
+      left: `${y.left}px`,
+      top: `${y.top}px`,
+      width: `${y.width}px`,
+      height: `${y.height}px`,
+      border: `1px solid ${e}`,
+      boxSizing: "border-box",
+      transform: `rotate(${-n.rotation}deg)`,
+      transformOrigin: `${n.pivot[0] * 100}% ${(1 - n.pivot[1]) * 100}%`,
+      pointerEvents: o ? "auto" : "none",
+      cursor: te.move
+    }), p.addEventListener("pointerdown", (S) => M("move", S));
+    const C = (S, v, P, T, m = "translate(-50%, -50%)") => {
+      const R = document.createElement("div");
+      return Object.assign(R.style, {
+        position: "absolute",
+        left: `${v * 100}%`,
+        top: `${P * 100}%`,
+        width: `${T}px`,
+        height: `${T}px`,
+        cursor: te[S],
+        transform: m,
+        pointerEvents: "auto"
+      }), R.addEventListener("pointerdown", (F) => {
+        F.stopPropagation(), M(S, F);
+      }), R;
+    };
+    for (const [S, v, P] of $e) {
+      const T = C(S, v, P, c);
+      T.style.background = t, p.appendChild(T);
+    }
+    for (const [S, v, P] of He)
+      p.appendChild(C(S, v, P, 26));
+    const E = C(
+      "pivot",
+      n.pivot[0],
+      1 - n.pivot[1],
+      x,
+      "translate(-50%, -50%) rotate(45deg)"
+    );
+    return Object.assign(E.style, {
+      border: "2px solid #ffffff",
+      background: "#111827",
+      boxSizing: "border-box"
+    }), p.appendChild(E), g.appendChild(p), h.appendChild(g), () => {
+      h.replaceChildren();
+    };
+  }, [e, t, y, o, M, n]), null;
+}, Q = {
+  // Pinning is opt-in. A serialized scene must never move an object until
+  // the author explicitly enables the component and chooses a target.
+  enabled: !1,
+  targetObjectId: null,
+  orientation: "none",
+  uv: { x: 0.5, y: 0.5 },
+  vertexNormal: !1,
+  offsetSpace: "local",
+  offsetPosition: { x: 0, y: 0, z: 0 },
+  offsetRotation: { x: 0, y: 0, z: 0 }
+}, Qe = (e, t, o, n) => {
+  const i = o.clone().sub(t), r = n.clone().sub(t), a = e.clone().sub(t), s = i.x * r.y - r.x * i.y;
+  if (Math.abs(s) < 1e-8) return null;
+  const l = (a.x * r.y - r.x * a.y) / s, d = (i.x * a.y - a.x * i.y) / s, f = 1 - l - d;
+  return f >= -1e-5 && l >= -1e-5 && d >= -1e-5 ? [f, l, d] : null;
+}, Ze = (e, t, o = !1) => {
+  const n = new K(t.x, t.y), i = new K(), r = new K(), a = new K(), s = new z(), l = new z(), d = new z(), f = new z(), y = new z(), w = new z();
+  let b = null;
+  if (e.traverse((h) => {
+    var v, P;
+    if (b || !h.isMesh) return;
+    const c = h, x = c.geometry, g = (v = x == null ? void 0 : x.attributes) == null ? void 0 : v.position, p = (P = x == null ? void 0 : x.attributes) == null ? void 0 : P.uv;
+    if (!g || !p) return;
+    const C = x.attributes.normal, E = x.index, S = (T) => (E == null ? void 0 : E.getX(T)) ?? T;
+    for (let T = 0; T < (E ? E.count : g.count); T += 3) {
+      const m = [S(T), S(T + 1), S(T + 2)];
+      i.set(p.getX(m[0]), p.getY(m[0])), r.set(p.getX(m[1]), p.getY(m[1])), a.set(p.getX(m[2]), p.getY(m[2]));
+      const R = Qe(n, i, r, a);
+      if (R) {
+        s.set(0, 0, 0), l.set(0, 0, 0), m.forEach((F, V) => {
+          d.fromBufferAttribute(g, F), s.addScaledVector(d, R[V]), C && o && l.addScaledVector(d.fromBufferAttribute(C, F), R[V]);
+        }), o || (f.fromBufferAttribute(g, m[0]), y.fromBufferAttribute(g, m[1]), w.fromBufferAttribute(g, m[2]), l.copy(y.sub(f).cross(w.sub(f)).normalize())), b = {
+          mesh: c,
+          localPosition: s.clone(),
+          localNormal: l.clone().normalize()
+        };
+        break;
+      }
+    }
+  }), b) return b;
+  const M = new Ae().setFromObject(e);
+  return {
+    mesh: e,
+    localPosition: e.worldToLocal(M.getCenter(new z())),
+    localNormal: new z(0, 1, 0)
+  };
+}, Je = (e) => ({
+  position: e.mesh.localToWorld(e.localPosition.clone()),
+  normal: e.localNormal.clone().transformDirection(e.mesh.matrixWorld).normalize()
+}), X = (e, t = 0) => Number.isFinite(e) ? e : t, oe = new z(), ne = new z(), ye = new B(), re = new Y(), ie = new Y(), et = new z(0, 1, 0), tt = (e) => {
+  e.position.set(0, 0, 0), e.quaternion.identity();
+}, ot = ({ settings: e, source: t, surface: o }) => {
+  e.orientation === "positionAndDirection" ? (ye.lookAt(o.position, o.position.clone().add(o.normal), et), re.setFromRotationMatrix(ye)) : re.identity(), t.quaternion.copy(re), ne.set(
+    X(e.offsetPosition.x),
+    X(e.offsetPosition.y),
+    X(e.offsetPosition.z)
+  ), e.offsetSpace === "local" && ne.applyQuaternion(t.quaternion), oe.copy(o.position).add(ne), t.parent && t.parent.worldToLocal(oe), t.position.copy(oe), ie.setFromEuler(
+    new H(
+      X(e.offsetRotation.x) * Math.PI / 180,
+      X(e.offsetRotation.y) * Math.PI / 180,
+      X(e.offsetRotation.z) * Math.PI / 180
+    )
+  ), e.offsetSpace === "local" ? t.quaternion.multiply(ie) : t.quaternion.premultiply(ie);
+}, oo = ({ target: e, settings: t, children: o }) => {
+  const n = Fe(), i = W(null), r = W(null), a = () => {
+    i.current && tt(i.current);
+  };
+  return k(() => {
+    r.current = null;
+  }, [t.targetObjectId]), k(() => {
+    t.enabled || a();
+  }, [t.enabled]), Oe(() => {
+    const s = e ?? n(t.targetObjectId);
+    if (!t.enabled || !s || !i.current) {
+      (!t.enabled || !s) && a();
+      return;
+    }
+    const l = `${t.uv.x}:${t.uv.y}:${t.vertexNormal ? "vertex" : "face"}`;
+    (!r.current || r.current.target !== s || r.current.key !== l) && (r.current = {
+      key: l,
+      target: s,
+      surface: Ze(s, t.uv, t.vertexNormal)
+    }), s.updateWorldMatrix(!0, !0);
+    const d = Je(r.current.surface);
+    ot({ source: i.current, surface: d, settings: t });
+  }), Le("group", { ref: i }, o);
+}, I = (e) => Math.round(e * 2) / 2, ge = (e) => Math.min(1, Math.max(0, e));
+function nt(e) {
+  return Math.min(
+    e.width / A.width,
+    e.height / A.height
+  ) || 1;
+}
+function rt({
+  resolved: e,
+  transform: t
+}) {
+  return e.size[0] / Math.max(Math.abs(t.size.width * t.scale2D.x), 1e-6) || 1;
+}
+function it({
+  parent: e,
+  resolved: t,
+  transform: o
+}) {
+  const r = 16 * ((Math.min(
+    e.width / A.width,
+    e.height / A.height
+  ) || 1) * (q / Math.max(o.referencePixelsPerUnit, 1e-6))), a = 0.028;
+  return [
+    r / Math.max(Math.abs(t.size[0]) * a, 1e-6),
+    r / Math.max(Math.abs(t.size[1]) * a, 1e-6),
+    1
+  ];
+}
+function st({
+  drag: e,
+  clientX: t,
+  clientY: o,
+  designScale: n
+}) {
+  const i = (t - e.startX) / n, r = -(o - e.startY) / n, a = {
+    x: e.startPointerDesign.x + i,
+    y: e.startPointerDesign.y + r
+  }, s = {
+    ...e.startTransform,
+    position: { ...e.startTransform.position },
+    size: { ...e.startTransform.size },
+    pivot: [...e.startTransform.pivot]
+  };
+  if (e.handle === "move")
+    return s.position = {
+      x: I(e.startTransform.position.x + i),
+      y: I(e.startTransform.position.y + r)
+    }, s;
+  if (e.handle === "pivot") {
+    const M = Math.max(
+      1,
+      e.startTransform.size.width * e.startTransform.scale2D.x
+    ), h = Math.max(
+      1,
+      e.startTransform.size.height * e.startTransform.scale2D.y
+    ), c = ge(e.startTransform.pivot[0] + i / M), x = ge(e.startTransform.pivot[1] + r / h);
+    return s.pivot = [I(c * 1e3) / 1e3, I(x * 1e3) / 1e3], s.position = {
+      x: I(
+        e.startTransform.position.x + (s.pivot[0] - e.startTransform.pivot[0]) * M
+      ),
+      y: I(
+        e.startTransform.position.y + (s.pivot[1] - e.startTransform.pivot[1]) * h
+      )
+    }, s;
+  }
+  if (e.handle.startsWith("rotate")) {
+    const M = Math.atan2(
+      e.startPointerDesign.y - e.startTransform.position.y,
+      e.startPointerDesign.x - e.startTransform.position.x
+    ), h = Math.atan2(
+      a.y - e.startTransform.position.y,
+      a.x - e.startTransform.position.x
+    );
+    return s.rotation = I(
+      e.startTransform.rotation + (h - M) * 180 / Math.PI
+    ), s;
+  }
+  const l = e.handle === "left" || e.handle.endsWith("Left"), d = e.handle === "right" || e.handle.endsWith("Right"), f = e.handle === "top" || e.handle.startsWith("top"), y = e.handle === "bottom" || e.handle.startsWith("bottom"), w = d ? i * 2 : l ? -i * 2 : 0, b = f ? r * 2 : y ? -r * 2 : 0;
+  return s.size = {
+    width: Math.max(1, I(e.startTransform.size.width + w)),
+    height: Math.max(1, I(e.startTransform.size.height + b))
+  }, s;
+}
+function at({
+  transform: e,
+  guideLayer: t,
+  guideColor: o,
+  onChange: n,
+  children: i
+}) {
+  const r = Ee(), { size: a } = xe(), s = W(n);
+  s.current = n;
+  const l = W(null), d = G(
+    () => pe({ transform: e, parentSize: r }),
+    [r, e]
+  ), f = nt(a), y = W(f);
+  y.current = f;
+  const w = rt({ resolved: d, transform: e }), b = U((x) => {
+    const g = l.current, p = s.current;
+    !g || !p || p(
+      st({
+        drag: g,
+        clientX: x.clientX,
+        clientY: x.clientY,
+        designScale: y.current
+      })
+    );
+  }, []), M = U(() => {
+    l.current = null, document.body.style.cursor = "", window.removeEventListener("pointermove", b), window.removeEventListener("pointerup", M);
+  }, [b]);
+  k(() => M, [M]);
+  const h = U(
+    (x, g) => {
+      n && (l.current = {
+        handle: x,
+        startX: g.nativeEvent.clientX,
+        startY: g.nativeEvent.clientY,
+        startPointerDesign: {
+          x: g.point.x / w,
+          y: g.point.y / w
+        },
+        startTransform: e
+      }, window.addEventListener("pointermove", b), window.addEventListener("pointerup", M));
+    },
+    [n, M, e, w, b]
+  ), c = G(
+    () => it({ parent: r, resolved: d, transform: e }),
+    [r, d, e]
+  );
+  return /* @__PURE__ */ u(
+    "group",
+    {
+      position: [
+        d.center[0] + (e.pivot[0] - 0.5) * d.size[0],
+        d.center[1] + (e.pivot[1] - 0.5) * d.size[1],
+        0
+      ],
+      rotation: d.rotation,
+      children: /* @__PURE__ */ u(
+        "group",
+        {
+          position: [
+            (0.5 - e.pivot[0]) * d.size[0],
+            (0.5 - e.pivot[1]) * d.size[1],
+            0
+          ],
+          scale: d.size,
+          children: /* @__PURE__ */ O(ze.Provider, { value: d.aspect, children: [
+            i,
+            e.showTransformGuides && t === "scene" ? /* @__PURE__ */ u(
+              ke,
+              {
+                color: o,
+                controlScale: c,
+                onHandlePointerDown: n ? h : void 0,
+                pivot: e.pivot,
+                pivotScale: c,
+                renderOrder: e.renderOrder + 1
+              }
+            ) : null,
+            e.showTransformGuides && t === "overlay" ? /* @__PURE__ */ u(
+              Ke,
+              {
+                color: o,
+                onChange: n,
+                transform: e
+              }
+            ) : null
+          ] })
+        }
+      )
+    }
+  );
+}
+const $ = {
+  tint: "#dff6ff",
+  opacity: 0.28,
+  frost: 0.35,
+  highlight: 0.55
+}, ve = (e) => ({
+  ...$,
+  ...e,
+  opacity: L.clamp((e == null ? void 0 : e.opacity) ?? $.opacity, 0, 1),
+  frost: L.clamp((e == null ? void 0 : e.frost) ?? $.frost, 0, 1),
+  highlight: L.clamp((e == null ? void 0 : e.highlight) ?? $.highlight, 0, 1)
+}), ct = `
+  varying vec2 vPosition;
+  void main() {
+    vPosition = position.xy;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, lt = `
+  uniform vec3 tint;
+  uniform float opacity;
+  uniform float frost;
+  uniform float highlight;
+  varying vec2 vPosition;
+
+  void main() {
+    float grain = fract(sin(dot(vPosition * 997.0, vec2(12.9898, 78.233))) * 43758.5453);
+    float sheen = smoothstep(0.15, 0.85, 1.0 - (vPosition.x + vPosition.y + 1.0) * 0.5);
+    vec3 frosted = mix(tint, vec3(1.0), frost * (0.18 + grain * 0.08));
+    vec3 color = mix(frosted, vec3(1.0), sheen * highlight * 0.32);
+    gl_FragColor = vec4(color, opacity);
+  }
+`, dt = ({ opacity: e = 1, value: t }) => {
+  const o = G(() => {
+    const n = ve(t);
+    return {
+      tint: { value: new Ce(n.tint) },
+      opacity: { value: n.opacity * e },
+      frost: { value: n.frost },
+      highlight: { value: n.highlight }
+    };
+  }, [e, t]);
+  return /* @__PURE__ */ u(
+    "shaderMaterial",
+    {
+      uniforms: o,
+      vertexShader: ct,
+      fragmentShader: lt,
+      transparent: !0,
+      depthTest: !1,
+      depthWrite: !1,
+      toneMapped: !1
+    }
+  );
+}, se = (e, t = 1) => Array.from({ length: e }, (o, n) => {
+  const i = n % 2 ? t * 0.5 : 0.5, r = -Math.PI / 2 + n / e * Math.PI * 2;
+  return [Math.cos(r) * i, Math.sin(r) * i, 0];
+}), pt = (e) => {
+  switch (e.kind) {
+    case "line":
+      return [
+        [e.lineStart.x - 0.5, 0.5 - e.lineStart.y, 0],
+        [e.lineEnd.x - 0.5, 0.5 - e.lineEnd.y, 0]
+      ];
+    case "polygon":
+      return se(Math.max(3, Math.round(e.sides)));
+    case "star":
+      return se(
+        Math.max(3, Math.round(e.sides)) * 2,
+        ce.MathUtils.clamp(e.innerRadiusRatio, 0.05, 0.95)
+      );
+    case "rectangle":
+      return [
+        [-0.5, -0.5, 0],
+        [0.5, -0.5, 0],
+        [0.5, 0.5, 0],
+        [-0.5, 0.5, 0]
+      ];
+    case "roundedRectangle": {
+      const t = ce.MathUtils.clamp(e.cornerRadius, 0, 0.5), o = [];
+      return [
+        [0.5 - t, 0.5 - t, 0],
+        [-0.5 + t, 0.5 - t, Math.PI / 2],
+        [-0.5 + t, -0.5 + t, Math.PI],
+        [0.5 - t, -0.5 + t, Math.PI * 1.5]
+      ].forEach(([i, r, a]) => {
+        for (let s = 0; s <= 6; s += 1) {
+          const l = a + s / 6 * (Math.PI / 2);
+          o.push([i + Math.cos(l) * t, r + Math.sin(l) * t, 0]);
+        }
+      }), o;
+    }
+    case "circle":
+    case "ellipse":
+    default:
+      return se(64);
+  }
+}, ft = (e) => {
+  const t = new ce.Shape();
+  return e.forEach(([o, n], i) => i ? t.lineTo(o, n) : t.moveTo(o, n)), t.closePath(), t;
+}, Z = {
+  kind: "rectangle",
+  fillColor: "#38bdf8",
+  fillOpacity: 1,
+  fillMode: "solid",
+  gradient: Ie,
+  glass: $,
+  strokeColor: "#ffffff",
+  strokeOpacity: 1,
+  strokeWidth: 3,
+  cornerRadius: 0.15,
+  sides: 5,
+  innerRadiusRatio: 0.45,
+  dashed: !1,
+  lineStart: { x: 0.1, y: 0.5 },
+  lineEnd: { x: 0.9, y: 0.5 }
+}, ht = (e) => {
+  const t = {
+    ...Z,
+    ...e,
+    lineStart: { ...Z.lineStart, ...e == null ? void 0 : e.lineStart },
+    lineEnd: { ...Z.lineEnd, ...e == null ? void 0 : e.lineEnd },
+    gradient: je(e == null ? void 0 : e.gradient),
+    glass: ve(e == null ? void 0 : e.glass)
+  }, o = (n, i) => Number.isFinite(n) ? n : i;
+  return {
+    ...t,
+    fillOpacity: L.clamp(o(t.fillOpacity, 1), 0, 1),
+    strokeOpacity: L.clamp(o(t.strokeOpacity, 1), 0, 1),
+    strokeWidth: Math.max(0, o(t.strokeWidth, 0)),
+    cornerRadius: L.clamp(o(t.cornerRadius, 0), 0, 0.5),
+    sides: L.clamp(Math.round(o(t.sides, 5)), 3, 12),
+    innerRadiusRatio: L.clamp(o(t.innerRadiusRatio, 0.45), 0.05, 0.95),
+    lineStart: {
+      x: L.clamp(o(t.lineStart.x, 0.1), 0, 1),
+      y: L.clamp(o(t.lineStart.y, 0.5), 0, 1)
+    },
+    lineEnd: {
+      x: L.clamp(o(t.lineEnd.x, 0.9), 0, 1),
+      y: L.clamp(o(t.lineEnd.y, 0.5), 0, 1)
+    }
+  };
+}, ut = ({
+  name: e,
+  renderOrder: t,
+  settings: o,
+  visible: n
+}) => {
+  const i = Pe(), r = G(() => pt(o), [o]), a = G(() => ft(r), [r]), l = ["circle", "polygon", "star"].includes(o.kind) ? [Math.min(1, 1 / i), Math.min(1, i), 1] : [1, 1, 1], f = o.kind !== "line" ? [...r, r[0]] : r;
+  return /* @__PURE__ */ O("group", { name: e, visible: n, scale: l, children: [
+    o.kind !== "line" && o.fillOpacity > 0 ? /* @__PURE__ */ O("mesh", { renderOrder: t, children: [
+      /* @__PURE__ */ u("shapeGeometry", { args: [a] }),
+      o.fillMode === "glass" ? /* @__PURE__ */ u(dt, { value: o.glass, opacity: o.fillOpacity }) : /* @__PURE__ */ u(
+        We,
+        {
+          settings: {
+            source: o.fillMode,
+            color: o.fillColor,
+            opacity: o.fillOpacity,
+            gradient: o.gradient
+          }
+        }
+      )
+    ] }) : null,
+    o.strokeWidth > 0 && o.strokeOpacity > 0 ? /* @__PURE__ */ u(
+      Ue,
+      {
+        points: f,
+        color: o.strokeColor,
+        lineWidth: o.strokeWidth,
+        opacity: o.strokeOpacity,
+        transparent: o.strokeOpacity < 1,
+        dashed: o.dashed,
+        dashSize: 0.05,
+        gapSize: 0.03,
+        depthTest: !1,
+        depthWrite: !1,
+        renderOrder: t + 1
+      }
+    ) : null
+  ] });
+}, no = ({
+  name: e,
+  onScreenTransformChange: t,
+  renderOrder: o,
+  settings: n,
+  transform: i,
+  transformGuideLayer: r = "scene",
+  visible: a = !0
+}) => {
+  const s = G(() => ht(n), [n]), l = G(
+    () => Ye(i ?? j),
+    [i]
+  );
+  return l.enabled ? /* @__PURE__ */ u(
+    at,
+    {
+      transform: l,
+      guideLayer: r,
+      guideColor: "#38bdf8",
+      onChange: t,
+      children: /* @__PURE__ */ u(
+        ut,
+        {
+          name: e,
+          settings: s,
+          visible: a && l.visible,
+          renderOrder: o ?? l.renderOrder
+        }
+      )
+    }
+  ) : null;
+};
+function ro(e) {
+  const { screenSpaceUI: t, screenImage: o } = e, { image: n, transformation: i } = o, r = n.src.trim();
+  return {
+    shouldRender: t.enabled && o.enabled && i.enabled,
+    props: {
+      source: n.sourceKind === "image" && r.length > 0 ? { kind: "image", src: r } : { kind: "default" },
+      transform: o.screenTransform,
+      coordinateSpace: i.coordinateSpace,
+      canvasSize: i.canvasSize,
+      position: [i.position.x, i.position.y],
+      size: [i.size.width, i.size.height],
+      rotation: i.rotation,
+      pivot: i.pivot,
+      stretchMode: n.stretchMode,
+      materialType: n.materialType,
+      blendMode: n.blendMode,
+      opacity: n.opacity,
+      color: n.color,
+      flipX: n.flipX,
+      flipY: n.flipY,
+      renderOrder: i.renderOrder,
+      transparent: n.transparent,
+      alphaTest: n.alphaTest,
+      overlay: i.overlay,
+      visible: i.visible
+    }
+  };
+}
+const fe = {
+  enabled: !0,
+  preset: "placeholder",
+  transformation: {
+    enabled: !0,
+    showFitGuides: !1,
+    coordinateSpace: "canvas",
+    canvasSize: { width: 720, height: 1280 },
+    position: { x: 0, y: 0 },
+    size: { width: 680, height: 1230 },
+    rotation: 0,
+    pivot: [0.5, 0.5],
+    renderOrder: 999,
+    overlay: !0,
+    visible: !0
+  },
+  screenTransform: {
+    ...j,
+    renderOrder: 999
+  },
+  image: {
+    sourceKind: "default",
+    src: "",
+    stretchMode: "fit",
+    materialType: "unlit",
+    blendMode: "normal",
+    opacity: 1,
+    color: "#ffffff",
+    flipX: !1,
+    flipY: !1,
+    transparent: !0,
+    alphaTest: 0
+  }
+}, io = {
+  screenImage: fe,
+  screenSpaceUI: {
+    enabled: !0
+  }
+}, mt = (e) => e * Math.PI / 180;
+function yt(e) {
+  if (!e) return;
+  const t = e.offset ?? 0, o = mt(e.angle ?? -45);
+  return {
+    color: e.color,
+    opacity: e.opacity,
+    blur: (e.feather ?? 0) * 100,
+    offsetX: Math.cos(o) * t,
+    offsetY: Math.sin(o) * t
+  };
+}
+function so(e) {
+  const { screenSpaceUI: t, screenText: o } = e, { content: n, layout: i, style: r, transformation: a } = o, s = r.background;
+  return {
+    shouldRender: t.enabled && o.enabled && a.enabled,
+    props: {
+      text: n.text,
+      screenTransform: o.screenTransform,
+      coordinateSpace: a.coordinateSpace,
+      canvasSize: a.canvasSize,
+      position: [a.position.x, a.position.y],
+      size: [a.size.width, a.size.height],
+      rotation: a.rotation,
+      pivot: a.pivot,
+      renderOrder: a.renderOrder,
+      overlay: a.overlay,
+      visible: a.visible,
+      showTransformGuides: a.showTransformGuides,
+      fontSize: r.fontSize,
+      fontFamily: r.fontFamily,
+      fontWeight: r.fontWeight,
+      fontStyle: r.fontStyle,
+      underline: r.underline,
+      strikethrough: r.strikethrough,
+      letterSpacing: r.letterSpacing,
+      lineSpacing: r.lineSpacing,
+      color: r.color,
+      opacity: r.opacity,
+      outlineEnabled: r.outlineEnabled,
+      strokeLayers: r.strokeLayers,
+      shadowEnabled: r.shadowEnabled,
+      shadowLayers: r.shadowLayers,
+      innerShadow: r.innerShadowEnabled ? yt(r.innerShadow) : void 0,
+      glow: r.glowEnabled ? r.glow : void 0,
+      bend: r.bendEnabled ? r.bend : void 0,
+      bgColor: s.enabled ? s.color : "transparent",
+      bgOpacity: s.opacity,
+      bgFit: s.fit,
+      bgAutoSize: s.autoSize,
+      bgFillMode: s.fillMode,
+      bgWidth: s.width,
+      bgHeight: s.height,
+      bgGradientStops: s.gradientStops,
+      bgTextureUrl: s.textureUrl,
+      bgTextureFit: s.textureFit,
+      bgTextureFlipX: s.textureFlipX,
+      bgTextureFlipY: s.textureFlipY,
+      padding: s.padding,
+      borderColor: s.borderEnabled ? s.borderColor : void 0,
+      borderWidth: s.borderEnabled ? s.borderWidth : 0,
+      borderRadius: s.borderRadius,
+      textAlign: i.textAlign,
+      verticalAlign: i.verticalAlign,
+      overflow: i.overflow,
+      resizeToFit: i.resizeToFit,
+      minFontSize: i.minFontSize
+    }
+  };
+}
+const gt = {
+  color: "#000000",
+  blur: 0,
+  offsetX: 7.071,
+  offsetY: -7.071,
+  opacity: 1,
+  offset: 10,
+  angle: -45,
+  feather: 0
+}, St = {
+  screenText: {
+    enabled: !0,
+    content: {
+      text: "Hello from Vincentt"
+    },
+    layout: {
+      textAlign: "center",
+      verticalAlign: "center",
+      overflow: "clip",
+      resizeToFit: !1,
+      minFontSize: 32
+    },
+    style: {
+      fontSize: 72,
+      fontFamily: '"Space Grotesk", sans-serif',
+      fontWeight: 400,
+      bold: !1,
+      fontStyle: "normal",
+      underline: !1,
+      strikethrough: !1,
+      letterSpacing: 0,
+      lineSpacing: 0.3,
+      color: "#ffffff",
+      opacity: 1,
+      aspect: 3,
+      outlineEnabled: !0,
+      shadowEnabled: !1,
+      innerShadowEnabled: !1,
+      innerShadow: {
+        color: "#000000",
+        opacity: 1,
+        offset: 10,
+        angle: -45,
+        feather: 0
+      },
+      glowEnabled: !1,
+      glow: {
+        color: "#ffffff",
+        style: "outward",
+        intensity: 0.5,
+        range: 0.5,
+        horizontalAngle: 0,
+        verticalAngle: 0
+      },
+      bendEnabled: !1,
+      bend: {
+        preset: "arc",
+        strength: 100
+      },
+      background: {
+        enabled: !1,
+        autoSize: !0,
+        fit: "text",
+        fillMode: "solid",
+        color: "#14286e",
+        opacity: 1,
+        borderRadius: 32,
+        padding: 0,
+        width: 540,
+        height: 220,
+        borderEnabled: !1,
+        borderWidth: 0,
+        borderColor: "#ffffff",
+        gradientStops: [
+          { color: "#14286e", position: 0 },
+          { color: "#3657d6", position: 0.5 },
+          { color: "#8ab4ff", position: 1 }
+        ],
+        textureUrl: "",
+        textureFit: "cover",
+        textureFlipX: !1,
+        textureFlipY: !1
+      },
+      strokeLayers: [{ color: "#0f172a", width: 12, opacity: 1 }],
+      shadowLayers: [gt]
+    },
+    screenTransform: {
+      ...j,
+      renderOrder: 1e3
+    },
+    transformation: {
+      enabled: !0,
+      showTransformGuides: !1,
+      coordinateSpace: "canvas",
+      canvasSize: { width: 720, height: 1280 },
+      position: { x: 0, y: 0 },
+      size: { width: 680, height: 1230 },
+      rotation: 0,
+      pivot: [0.5, 0.5],
+      renderOrder: 1e3,
+      overlay: !0,
+      visible: !0
+    },
+    textArtPreset: "clean"
+  },
+  screenImage: fe,
+  screenSpaceUI: {
+    enabled: !0
+  }
+}, Te = (e) => {
+  const t = typeof crypto < "u" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  return `${e}_${t}`;
+}, bt = () => Te("obj"), xt = () => Te("cmp"), N = (e) => typeof structuredClone == "function" ? structuredClone(e) : JSON.parse(JSON.stringify(e)), vt = () => N(Ne), Tt = () => N(j), wt = () => N(fe), Mt = () => N(St.screenText), Et = () => N(Z), zt = () => N(Re), Pt = () => N(Ge), Rt = () => ({
+  type: "standard",
+  color: "#ffffff",
+  opacity: 1,
+  wireframe: !1,
+  roughness: 0.42,
+  metalness: 0.08
+}), Ot = () => ({
+  flipX: !1,
+  flipY: !1
+}), Dt = () => ({
+  enabled: !0,
+  type: "directional",
+  color: "#ffffff",
+  intensity: 2.2,
+  castShadow: !0,
+  distance: 10,
+  angle: Math.PI / 6,
+  penumbra: 0.2,
+  decay: 2,
+  showHelper: !1
+}), Lt = () => ({
+  enabled: !1,
+  targetObjectId: null,
+  mode: "point",
+  inheritChildren: !1,
+  offsetRotation: { x: 0, y: 0, z: 0 }
+}), At = () => ({
+  ...Q,
+  uv: { ...Q.uv },
+  offsetPosition: { ...Q.offsetPosition },
+  offsetRotation: { ...Q.offsetRotation }
+}), Ct = () => N(_e), Ft = {
+  Transform: vt,
+  ScreenTransform: Tt,
+  ScreenImage: wt,
+  ScreenText: Mt,
+  ScreenShape: Et,
+  MeshRenderer: zt,
+  FaceMeshRenderer: Pt,
+  Material: Rt,
+  Texture: Ot,
+  Light: Dt,
+  LookAt: Lt,
+  PinToMesh: At,
+  TrackingAnchor: Ct
+}, ao = ({
+  componentIds: e = [],
+  enabled: t = !0,
+  id: o = bt(),
+  parentObjectId: n = null,
+  childObjectIds: i = [],
+  renderGroupId: r,
+  layerId: a,
+  name: s
+}) => ({
+  id: o,
+  name: s,
+  enabled: t,
+  parentObjectId: n,
+  childObjectIds: i,
+  layerId: a,
+  renderGroupId: r ?? a,
+  componentIds: e
+}), co = (e, t) => ({
+  id: xt(),
+  objectId: t,
+  type: e,
+  enabled: !0,
+  settings: Ft[e]()
+}), ee = (e, t) => {
+  const o = e.objects[t];
+  return o ? o.componentIds.map((n) => e.components[n]).filter((n) => !!n) : [];
+}, lo = () => {
+  let e = null, t = null, o = null, n = [];
+  return (i, r) => {
+    const a = i.objects[r];
+    if (!a)
+      return e = i, t = r, o = null, n = [], n;
+    const s = a.componentIds;
+    return e === i && t === r && o === s && n.length === s.length && n.every((d) => i.components[d.id] === d) || (e = i, t = r, o = s, n = ee(i, r)), n;
+  };
+}, po = (e, t) => {
+  const o = e.objects[t.objectId];
+  return o ? {
+    ...e,
+    objects: {
+      ...e.objects,
+      [o.id]: {
+        ...o,
+        componentIds: [...o.componentIds, t.id]
+      }
+    },
+    components: {
+      ...e.components,
+      [t.id]: t
+    }
+  } : e;
+}, fo = (e, t, o, n) => {
+  const i = e.objects[t];
+  if (!i || i.componentIds.indexOf(o) < 0) return e;
+  const a = i.componentIds.filter((s) => s !== o);
+  return a.splice(Math.max(0, Math.min(n, a.length)), 0, o), {
+    ...e,
+    objects: {
+      ...e.objects,
+      [t]: { ...i, componentIds: a }
+    }
+  };
+}, ho = (e, t, o) => {
+  const n = e.objects[t];
+  if (!n) return e;
+  const i = { ...e.components };
+  return delete i[o], {
+    ...e,
+    objects: {
+      ...e.objects,
+      [t]: {
+        ...n,
+        componentIds: n.componentIds.filter((r) => r !== o)
+      }
+    },
+    components: i
+  };
+}, Se = (e, t) => e.components[t.id] ? {
+  ...e,
+  components: {
+    ...e.components,
+    [t.id]: t
+  }
+} : e, _t = (e, t) => e.objects[t.id] ? {
+  ...e,
+  objects: {
+    ...e.objects,
+    [t.id]: t
+  }
+} : e, It = (e, t) => {
+  const o = e.objects[t], n = (o == null ? void 0 : o.childObjectIds) ?? [], i = Object.values(e.objects).filter((a) => a.parentObjectId === t).map((a) => a.id);
+  return [.../* @__PURE__ */ new Set([...n, ...i])].map((a) => e.objects[a]).filter((a) => !!a);
+}, jt = (e, t, o) => {
+  var r;
+  let n = o;
+  const i = /* @__PURE__ */ new Set();
+  for (; n; ) {
+    if (n === t || i.has(n)) return !0;
+    i.add(n), n = ((r = e.objects[n]) == null ? void 0 : r.parentObjectId) ?? null;
+  }
+  return !1;
+}, be = (e, t) => {
+  const o = new Set(ee(e, t).map((n) => n.type));
+  return o.has("Transform") ? "3d" : o.has("ScreenTransform") ? "2d" : null;
+}, Wt = (e, t, o, n) => {
+  const i = e.objects[t];
+  if (!i || o !== null && !e.objects[o]) return e;
+  if (o !== null) {
+    const s = be(e, t), l = be(e, o);
+    if (s && l && s !== l) return e;
+  }
+  if (jt(e, t, o)) return e;
+  const r = i.parentObjectId ?? null;
+  if (r === o && o === null) return e;
+  const a = { ...e.objects };
+  if (r && a[r]) {
+    const s = a[r];
+    a[r] = {
+      ...s,
+      childObjectIds: (s.childObjectIds ?? []).filter((l) => l !== t)
+    };
+  }
+  if (a[t] = { ...i, parentObjectId: o }, o) {
+    const s = a[o], l = (s.childObjectIds ?? []).filter((d) => d !== t);
+    l.splice(
+      Math.max(0, Math.min(n ?? l.length, l.length)),
+      0,
+      t
+    ), a[o] = { ...s, childObjectIds: l };
+  }
+  return { ...e, objects: a };
+}, ae = Math.PI / 180, J = 180 / Math.PI, D = (e) => Number(e.toFixed(4)), Gt = (e) => (e == null ? void 0 : e.type) === "Transform", we = (e, t) => ee(e, t).find(Gt) ?? null, Nt = (e) => (e == null ? void 0 : e.type) === "ScreenTransform", Me = (e, t) => ee(e, t).find(Nt) ?? null, Ut = (e) => new B().compose(
+  new z(e.position.x, e.position.y, e.position.z),
+  new Y().setFromEuler(
+    new H(
+      e.rotation.x * ae,
+      e.rotation.y * ae,
+      e.rotation.z * ae
+    )
+  ),
+  new z(e.scale.x, e.scale.y, e.scale.z)
+), kt = (e, t) => {
+  const o = we(e, t);
+  return o ? Ut(o.settings) : new B();
+}, le = (e, t) => {
+  const o = e.objects[t], n = kt(e, t);
+  return !(o != null && o.parentObjectId) || !e.objects[o.parentObjectId] ? n : le(e, o.parentObjectId).multiply(n);
+}, Xt = (e) => {
+  const t = pe({
+    transform: e,
+    parentSize: A,
+    snapIncrement: 0
+  });
+  return new B().compose(
+    new z(...t.center),
+    new Y().setFromEuler(new H(...t.rotation)),
+    new z(...t.size)
+  );
+}, de = (e, t) => {
+  var r;
+  const o = Me(e, t), n = o ? Xt(o.settings) : new B(), i = (r = e.objects[t]) == null ? void 0 : r.parentObjectId;
+  return !i || !e.objects[i] ? n : de(e, i).multiply(n);
+}, Bt = (e, t) => {
+  const o = new z(), n = new Y(), i = new z();
+  e.decompose(o, n, i);
+  const r = new H().setFromQuaternion(n);
+  return {
+    ...t,
+    position: {
+      x: D(o.x),
+      y: D(o.y),
+      z: D(o.z)
+    },
+    rotation: {
+      x: D(r.x * J),
+      y: D(r.y * J),
+      z: D(r.z * J)
+    },
+    scale: {
+      x: D(i.x),
+      y: D(i.y),
+      z: D(i.z)
+    }
+  };
+}, Yt = (e, t) => {
+  const o = new z(), n = new Y(), i = new z();
+  e.decompose(o, n, i);
+  const r = new H().setFromQuaternion(n), a = q / t.referencePixelsPerUnit, s = Math.abs(i.x), l = Math.abs(i.y), d = (t.pivot[0] - 0.5) * s, f = (t.pivot[1] - 0.5) * l;
+  return {
+    ...t,
+    position: {
+      x: D((o.x + d) / a),
+      y: D((o.y + f) / a)
+    },
+    rotation: D(r.z * J),
+    scale2D: {
+      x: D(s / (t.size.width * a)),
+      y: D(l / (t.size.height * a))
+    }
+  };
+}, uo = (e, t, o, n) => {
+  const i = we(e, t), r = Me(e, t), a = i ? le(e, t) : r ? de(e, t) : null, s = Wt(e, t, o, n);
+  if (s === e || !a) return s;
+  const d = (o ? i ? le(s, o) : de(s, o) : new B()).clone().invert().multiply(a);
+  return r ? Se(s, {
+    ...r,
+    settings: Yt(d, r.settings)
+  }) : i ? Se(s, {
+    ...i,
+    settings: Bt(d, i.settings)
+  }) : s;
+}, mo = (e, t, o) => {
+  const n = e.objects[t];
+  return n ? _t(e, { ...n, enabled: o }) : e;
+}, yo = (e, t) => {
+  const o = e.objects[t];
+  if (!o) return e;
+  const n = It(e, t).map((s) => s.id), i = { ...e.objects };
+  delete i[t];
+  const r = Object.fromEntries(
+    Object.entries(i).map(([s, l]) => [
+      s,
+      n.includes(s) || l.parentObjectId === t ? { ...l, parentObjectId: null } : {
+        ...l,
+        childObjectIds: (l.childObjectIds ?? []).filter(
+          (d) => d !== t
+        )
+      }
+    ])
+  ), a = { ...e.components };
+  for (const s of o.componentIds)
+    delete a[s];
+  return { ...e, objects: r, components: a };
+}, $t = 30, go = 31, So = (e, t = 1) => {
+  const o = t + e;
+  if (o < 1 || o > $t)
+    throw new RangeError(`Render-group layer ${o} is outside the supported range 1-30.`);
+  return o;
+}, bo = ({
+  renderer: e,
+  scene: t,
+  camera: o,
+  layers: n,
+  includeDefaultLayer: i = !0
+}) => {
+  const r = o.layers.mask, a = e.autoClear;
+  try {
+    if (e.autoClear = !1, e.clear(!0, !0, !0), n.length === 0) {
+      o.layers.set(0), e.render(t, o);
+      return;
+    }
+    n.forEach((s, l) => {
+      o.layers.set(s), i && s !== 0 && o.layers.enable(0), l > 0 && e.clearDepth(), e.render(t, o);
+    });
+  } finally {
+    o.layers.mask = r, e.autoClear = a;
+  }
+};
+export {
+  mo as A,
+  So as B,
+  ve as C,
+  $ as D,
+  no as E,
+  Z as F,
+  ht as G,
+  go as H,
+  bo as I,
+  fe as J,
+  io as K,
+  ro as L,
+  $t as M,
+  St as N,
+  gt as O,
+  oo as P,
+  yt as Q,
+  so as R,
+  dt as S,
+  Xe as T,
+  q as U,
+  j as V,
+  A as W,
+  Ye as X,
+  pe as Y,
+  at as Z,
+  po as a,
+  co as b,
+  Ft as c,
+  Pt as d,
+  Rt as e,
+  zt as f,
+  wt as g,
+  Mt as h,
+  Et as i,
+  Tt as j,
+  Ot as k,
+  vt as l,
+  xt as m,
+  Te as n,
+  ao as o,
+  bt as p,
+  lo as q,
+  yo as r,
+  ee as s,
+  It as t,
+  fo as u,
+  ho as v,
+  Se as w,
+  _t as x,
+  Wt as y,
+  uo as z
+};