@vincentt-xr/sdk 2.0.0-alpha.7 → 2.0.0-alpha.8

package/dist/renderPasses-NnKZVfBy.js

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