@rendiv/core 0.1.0

package/dist/index.js

@@ -0,0 +1,829 @@
+import G, { createContext as P, useContext as p, useEffect as N, forwardRef as ie, useId as se, useMemo as H, Children as J, useRef as F, useCallback as V, useState as ae } from "react";
+import { jsx as E, Fragment as ce } from "react/jsx-runtime";
+const x = P({
+  frame: 0,
+  playing: !1,
+  playingRef: { current: !1 }
+}), R = P({
+  id: null,
+  from: 0,
+  durationInFrames: 1 / 0,
+  parentOffset: 0,
+  accumulatedOffset: 0,
+  localOffset: 0
+});
+function Ne() {
+  const e = p(x), n = p(R);
+  return e.frame - n.accumulatedOffset;
+}
+const z = P(null);
+function _e() {
+  const e = p(z);
+  if (!e)
+    throw new Error(
+      "useCompositionConfig() must be called inside a <Composition>, <Player>, or during rendering."
+    );
+  return e;
+}
+const X = () => {
+}, ee = P({
+  compositions: [],
+  registerComposition: X,
+  unregisterComposition: X,
+  currentCompositionId: null,
+  setCurrentCompositionId: X,
+  inputProps: {}
+}), A = P(null);
+function Fe(e) {
+  const { registerComposition: n, unregisterComposition: t } = p(ee), o = p(A);
+  return N(() => (n({
+    id: e.id,
+    component: e.component,
+    durationInFrames: e.durationInFrames,
+    fps: e.fps,
+    width: e.width,
+    height: e.height,
+    defaultProps: e.defaultProps ?? {},
+    group: o,
+    resolveConfig: e.resolveConfig,
+    type: "composition"
+  }), () => t(e.id)), [e.id]), null;
+}
+const le = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  width: "100%",
+  height: "100%",
+  display: "flex",
+  flexDirection: "column"
+}, U = ie(
+  ({ style: e, ...n }, t) => /* @__PURE__ */ E(
+    "div",
+    {
+      ref: t,
+      style: { ...le, ...e },
+      ...n
+    }
+  )
+);
+U.displayName = "Fill";
+const ne = ({
+  from: e = 0,
+  durationInFrames: n = 1 / 0,
+  name: t,
+  layout: o = "absolute-fill",
+  style: r,
+  children: i
+}) => {
+  const s = p(R), a = p(x), l = se(), d = s.accumulatedOffset + e, g = a.frame;
+  N(() => {
+    if (typeof window > "u") return;
+    const y = window;
+    y.__RENDIV_TIMELINE_ENTRIES__ || (y.__RENDIV_TIMELINE_ENTRIES__ = /* @__PURE__ */ new Map());
+    const u = y.__RENDIV_TIMELINE_ENTRIES__, c = s.id, f = { id: l, name: t ?? "Sequence", from: d, durationInFrames: n, parentId: c };
+    return u.set(l, f), document.dispatchEvent(new CustomEvent("rendiv:timeline-sync")), () => {
+      u.delete(l), document.dispatchEvent(new CustomEvent("rendiv:timeline-sync"));
+    };
+  }, [l, t, d, n]);
+  const m = H(
+    () => ({
+      id: l,
+      from: d,
+      durationInFrames: n,
+      parentOffset: s.accumulatedOffset,
+      accumulatedOffset: d,
+      localOffset: e
+    }),
+    [l, d, n, s.accumulatedOffset, e]
+  );
+  if (g < d || g >= d + n) return null;
+  const b = /* @__PURE__ */ E(R.Provider, { value: m, children: i });
+  return o === "none" ? b : /* @__PURE__ */ E(U, { style: r, children: b });
+};
+ne.displayName = "Sequence";
+function xe(e) {
+  const { registerComposition: n, unregisterComposition: t } = p(ee), o = p(A);
+  return N(() => (n({
+    id: e.id,
+    component: e.component,
+    durationInFrames: 1,
+    fps: 30,
+    width: e.width,
+    height: e.height,
+    defaultProps: e.defaultProps ?? {},
+    group: o,
+    type: "still"
+  }), () => t(e.id)), [e.id]), null;
+}
+const ue = ({ name: e, children: n }) => {
+  const t = p(A), o = t ? `${t}/${e}` : e;
+  return /* @__PURE__ */ E(A.Provider, { value: o, children: n });
+};
+ue.displayName = "Folder";
+function j(e) {
+  throw new Error(
+    "<Series.Sequence> can only be used as a direct child of <Series>."
+  );
+}
+j.displayName = "Series.Sequence";
+function te({ children: e }) {
+  const n = J.toArray(e);
+  let t = 0;
+  const o = [];
+  for (const r of n) {
+    if (!G.isValidElement(r)) continue;
+    if (r.type !== j)
+      throw new Error(
+        "Only <Series.Sequence> elements are allowed as children of <Series>."
+      );
+    const {
+      durationInFrames: i,
+      offset: s = 0,
+      name: a,
+      layout: l,
+      style: d,
+      children: g
+    } = r.props, m = t + s;
+    let b = a;
+    if (!b) {
+      const y = J.toArray(g);
+      if (y.length > 0) {
+        const u = y[0];
+        if (G.isValidElement(u) && typeof u.type != "string") {
+          const c = u.type;
+          b = c.displayName || c.name;
+        }
+      }
+    }
+    o.push(
+      /* @__PURE__ */ E(
+        ne,
+        {
+          from: m,
+          durationInFrames: i,
+          name: b,
+          layout: l,
+          style: d,
+          children: g
+        },
+        r.key ?? o.length
+      )
+    ), t = m + i;
+  }
+  return /* @__PURE__ */ E(ce, { children: o });
+}
+te.displayName = "Series";
+const Re = Object.assign(te, {
+  Sequence: j
+});
+function fe({
+  durationInFrames: e,
+  times: n = 1 / 0,
+  layout: t = "absolute-fill",
+  style: o,
+  children: r
+}) {
+  const i = p(x), s = p(R), a = i.frame - s.accumulatedOffset;
+  if (a < 0 || n !== 1 / 0 && a >= e * n) return null;
+  const l = a % e, d = H(
+    () => ({
+      frame: l + s.accumulatedOffset,
+      playing: i.playing,
+      playingRef: i.playingRef
+    }),
+    [l, s.accumulatedOffset, i.playing, i.playingRef]
+  ), g = H(
+    () => ({
+      id: null,
+      from: s.accumulatedOffset,
+      durationInFrames: e,
+      parentOffset: s.accumulatedOffset,
+      accumulatedOffset: s.accumulatedOffset,
+      localOffset: 0
+    }),
+    [s.accumulatedOffset, e]
+  ), m = /* @__PURE__ */ E(x.Provider, { value: d, children: /* @__PURE__ */ E(R.Provider, { value: g, children: r }) });
+  return t === "none" ? m : /* @__PURE__ */ E(U, { style: o, children: m });
+}
+fe.displayName = "Loop";
+function de({ frame: e, children: n }) {
+  const t = p(x), o = H(
+    () => ({
+      frame: e,
+      playing: t.playing,
+      playingRef: t.playingRef
+    }),
+    [e, t.playing, t.playingRef]
+  );
+  return /* @__PURE__ */ E(x.Provider, { value: o, children: n });
+}
+de.displayName = "Freeze";
+let me = 0;
+const $ = /* @__PURE__ */ new Map();
+function D(e, n) {
+  const t = ++me, o = e ?? `Handle ${t}`, { timeoutInMilliseconds: r } = n ?? {};
+  let i = null;
+  return r !== void 0 && r > 0 && (i = setTimeout(() => {
+    if ($.has(t))
+      throw $.delete(t), new Error(
+        `holdRender() timed out after ${r}ms (label: "${o}"). You can increase the timeout by passing a larger timeoutInMilliseconds to holdRender().`
+      );
+  }, r)), $.set(t, { label: o, timeoutId: i }), t;
+}
+function _(e) {
+  const n = $.get(e);
+  if (!n)
+    throw new Error(
+      `releaseRender() was called with handle ${e}, but no corresponding holdRender() exists.`
+    );
+  n.timeoutId !== null && clearTimeout(n.timeoutId), $.delete(e);
+}
+function Te(e) {
+  throw new Error(`Render cancelled: ${e}`);
+}
+function $e() {
+  return $.size;
+}
+function Pe() {
+  return Array.from($.values()).map((e) => e.label);
+}
+function he({
+  holdRenderTimeout: e = 3e4,
+  onLoad: n,
+  onError: t,
+  ...o
+}) {
+  const r = F(null);
+  N(() => {
+    const a = D(
+      `Loading <Img> with src="${o.src}"`,
+      { timeoutInMilliseconds: e }
+    );
+    return r.current = a, () => {
+      r.current !== null && (_(r.current), r.current = null);
+    };
+  }, [o.src, e]);
+  const i = V(
+    (a) => {
+      r.current !== null && (_(r.current), r.current = null), n == null || n(a);
+    },
+    [n]
+  ), s = V(
+    (a) => {
+      r.current !== null && (_(r.current), r.current = null), t == null || t(a);
+    },
+    [t]
+  );
+  return /* @__PURE__ */ E(
+    "img",
+    {
+      ...o,
+      onLoad: i,
+      onError: s
+    }
+  );
+}
+he.displayName = "Img";
+const Y = P({
+  environment: "studio"
+});
+function ge({
+  src: e,
+  startFrom: n = 0,
+  endAt: t,
+  volume: o = 1,
+  playbackRate: r = 1,
+  muted: i = !1,
+  style: s,
+  className: a,
+  holdRenderTimeout: l = 3e4,
+  ...d
+}) {
+  const g = F(null), m = p(x), b = p(R), y = p(z), { environment: u } = p(Y), c = F(null), f = F(null), w = u === "rendering", v = (y == null ? void 0 : y.fps) ?? 30, M = m.frame - b.accumulatedOffset, I = M + n, C = I / v;
+  N(() => {
+    const h = D(
+      `Loading <Video> metadata for src="${e}"`,
+      { timeoutInMilliseconds: l }
+    );
+    return c.current = h, () => {
+      c.current !== null && (_(c.current), c.current = null);
+    };
+  }, [e, l]);
+  const T = V(() => {
+    c.current !== null && (_(c.current), c.current = null);
+  }, []), q = V(() => {
+    c.current !== null && (_(c.current), c.current = null);
+  }, []);
+  return N(() => {
+    const h = g.current;
+    h && (h.volume = o, h.muted = i);
+  }, [o, i]), N(() => {
+    const h = g.current;
+    h && (h.playbackRate = r);
+  }, [r]), N(() => {
+    const h = g.current;
+    if (h) {
+      if (t !== void 0 && I >= t) {
+        h.pause();
+        return;
+      }
+      if (w) {
+        if (h.pause(), f.current !== C) {
+          f.current = C;
+          const S = D(
+            `Seeking <Video> to ${C.toFixed(3)}s`,
+            { timeoutInMilliseconds: l }
+          ), k = () => {
+            _(S), h.removeEventListener("seeked", k);
+          };
+          h.addEventListener("seeked", k), h.currentTime = C;
+        }
+      } else
+        Math.abs(h.currentTime - C) > 0.1 && (h.currentTime = C), m.playing && h.paused ? h.play().catch(() => {
+        }) : !m.playing && !h.paused && h.pause();
+    }
+  }, [M, w, C, m.playing, t, I, l]), /* @__PURE__ */ E(
+    "video",
+    {
+      ref: g,
+      src: e,
+      preload: "auto",
+      playsInline: !0,
+      style: s,
+      className: a,
+      onLoadedMetadata: T,
+      onError: q,
+      ...d
+    }
+  );
+}
+ge.displayName = "Video";
+function pe({
+  src: e,
+  startFrom: n = 0,
+  endAt: t,
+  volume: o = 1,
+  playbackRate: r = 1,
+  muted: i = !1
+}) {
+  const s = F(null), a = p(x), l = p(R), d = p(z), { environment: g } = p(Y), m = g === "rendering", b = (d == null ? void 0 : d.fps) ?? 30, y = a.frame - l.accumulatedOffset, u = y + n, c = u / b;
+  return N(() => {
+    if (m) return;
+    const f = s.current;
+    if (!f) return;
+    if (f.volume = o, f.muted = i, f.playbackRate = r, t !== void 0 && u >= t) {
+      f.pause();
+      return;
+    }
+    Math.abs(f.currentTime - c) > 0.1 && (f.currentTime = c), a.playing && f.paused ? f.play().catch(() => {
+    }) : !a.playing && !f.paused && f.pause();
+  }, [y, m, c, a.playing, o, i, r, t, u]), m ? null : /* @__PURE__ */ E(
+    "audio",
+    {
+      ref: s,
+      src: e,
+      preload: "auto"
+    }
+  );
+}
+pe.displayName = "Audio";
+function ye({
+  src: e,
+  width: n,
+  height: t,
+  style: o,
+  className: r,
+  holdRenderTimeout: i = 3e4
+}) {
+  const s = F(null), a = p(x), l = p(R), d = p(z), g = F([]), m = F(null), [b, y] = ae(!1), u = (d == null ? void 0 : d.fps) ?? 30, c = a.frame - l.accumulatedOffset;
+  return N(() => {
+    const f = D(
+      `Loading <AnimatedImage> frames from "${e}"`,
+      { timeoutInMilliseconds: i }
+    );
+    m.current = f;
+    let w = !1;
+    async function v() {
+      try {
+        const I = await (await fetch(e)).blob();
+        if (typeof ImageDecoder < "u") {
+          const C = new ImageDecoder({
+            data: await I.arrayBuffer(),
+            type: I.type
+          });
+          await C.tracks.ready;
+          const T = C.tracks.selectedTrack;
+          if (!T) throw new Error("No image track found");
+          const q = T.frameCount, h = [];
+          for (let S = 0; S < q; S++) {
+            const k = await C.decode({ frameIndex: S }), re = await createImageBitmap(k.image), oe = (k.image.duration ?? 1e5) / 1e3;
+            h.push({ image: re, duration: oe }), k.image.close();
+          }
+          C.close(), w || (g.current = h, y(!0));
+        } else {
+          const C = await createImageBitmap(I);
+          w || (g.current = [{ image: C, duration: 1 / 0 }], y(!0));
+        }
+      } catch (M) {
+        console.error("AnimatedImage: failed to decode frames", M);
+      } finally {
+        m.current !== null && (_(m.current), m.current = null);
+      }
+    }
+    return v(), () => {
+      w = !0, m.current !== null && (_(m.current), m.current = null);
+    };
+  }, [e, i]), N(() => {
+    if (!b || g.current.length === 0) return;
+    const f = s.current;
+    if (!f) return;
+    const w = f.getContext("2d");
+    if (!w) return;
+    const v = g.current, M = c / u * 1e3;
+    let I = 0;
+    for (const S of v)
+      I += S.duration;
+    if (I <= 0) return;
+    const C = (M % I + I) % I;
+    let T = 0, q = 0;
+    for (let S = 0; S < v.length; S++)
+      if (T += v[S].duration, C < T) {
+        q = S;
+        break;
+      }
+    const h = v[q];
+    h && (f.width = n ?? h.image.width, f.height = t ?? h.image.height, w.clearRect(0, 0, f.width, f.height), w.drawImage(h.image, 0, 0, f.width, f.height));
+  }, [c, u, b, n, t]), /* @__PURE__ */ E(
+    "canvas",
+    {
+      ref: s,
+      width: n,
+      height: t,
+      style: o,
+      className: r
+    }
+  );
+}
+ye.displayName = "AnimatedImage";
+function we({
+  holdRenderTimeout: e = 3e4,
+  onLoad: n,
+  onError: t,
+  ...o
+}) {
+  const r = F(null);
+  N(() => {
+    const a = D(
+      `Loading <IFrame> with src="${o.src}"`,
+      { timeoutInMilliseconds: e }
+    );
+    return r.current = a, () => {
+      r.current !== null && (_(r.current), r.current = null);
+    };
+  }, [o.src, e]);
+  const i = V(
+    (a) => {
+      r.current !== null && (_(r.current), r.current = null), n == null || n(a);
+    },
+    [n]
+  ), s = V(
+    (a) => {
+      r.current !== null && (_(r.current), r.current = null), t == null || t(a);
+    },
+    [t]
+  );
+  return /* @__PURE__ */ E(
+    "iframe",
+    {
+      ...o,
+      onLoad: i,
+      onError: s
+    }
+  );
+}
+we.displayName = "IFrame";
+function be(e, n) {
+  for (let t = 1; t < n.length; t++)
+    if (e <= n[t]) return t - 1;
+  return n.length - 2;
+}
+function B(e, n, t, o, r, i) {
+  let s;
+  return n === t ? s = 0 : s = (e - n) / (t - n), i && (s = i(s)), o + s * (r - o);
+}
+function O(e, n, t, o) {
+  if (n.length !== t.length)
+    throw new Error(
+      `inputRange (${n.length}) and outputRange (${t.length}) must have the same length.`
+    );
+  if (n.length < 2)
+    throw new Error("inputRange and outputRange must have at least 2 elements.");
+  for (let l = 1; l < n.length; l++)
+    if (n[l] < n[l - 1])
+      throw new Error("inputRange must be monotonically non-decreasing.");
+  const {
+    easing: r,
+    extrapolateLeft: i = "extend",
+    extrapolateRight: s = "extend"
+  } = o ?? {};
+  if (e < n[0])
+    return i === "clamp" ? t[0] : i === "identity" ? e : B(
+      e,
+      n[0],
+      n[1],
+      t[0],
+      t[1],
+      r
+    );
+  if (e > n[n.length - 1]) {
+    if (s === "clamp")
+      return t[t.length - 1];
+    if (s === "identity")
+      return e;
+    const l = n.length - 1;
+    return B(
+      e,
+      n[l - 1],
+      n[l],
+      t[l - 1],
+      t[l],
+      r
+    );
+  }
+  const a = be(e, n);
+  return B(
+    e,
+    n[a],
+    n[a + 1],
+    t[a],
+    t[a + 1],
+    r
+  );
+}
+function ve(e, n, t, o, r, i, s) {
+  const a = -o * (e - t), l = -r * n, d = (a + l) / i, g = n + d * s;
+  return { position: e + g * s, velocity: g };
+}
+function Ie(e) {
+  const {
+    frame: n,
+    fps: t,
+    config: o = {},
+    from: r = 0,
+    to: i = 1,
+    durationInFrames: s,
+    durationRestThreshold: a = 5e-3
+  } = e, {
+    damping: l = 10,
+    mass: d = 1,
+    stiffness: g = 100,
+    clampOvershoot: m = !1
+  } = o;
+  if (n < 0) return r;
+  if (s !== void 0 && n >= s)
+    return i;
+  const b = 1 / t, y = 4, u = b / y;
+  let c = r, f = 0;
+  for (let w = 0; w < n; w++) {
+    for (let v = 0; v < y; v++) {
+      const M = ve(c, f, i, g, l, d, u);
+      c = M.position, f = M.velocity;
+    }
+    if (m && (r < i ? c = Math.min(c, i) : c = Math.max(c, i), c === i && (f = 0)), Math.abs(c - i) < a && Math.abs(f) < a)
+      return i;
+  }
+  return c;
+}
+function qe(e) {
+  const {
+    fps: n,
+    config: t,
+    from: o = 0,
+    to: r = 1,
+    threshold: i = 5e-3
+  } = e, s = n * 60;
+  for (let a = 0; a < s; a++) {
+    const l = Ie({
+      frame: a,
+      fps: n,
+      config: t,
+      from: o,
+      to: r,
+      durationRestThreshold: i
+    });
+    if (Math.abs(l - r) < i)
+      return a;
+  }
+  return s;
+}
+function L(e, n, t, o) {
+  const r = 3 * e, i = 3 * (t - e) - r, s = 1 - r - i, a = 3 * n, l = 3 * (o - n) - a, d = 1 - a - l;
+  function g(u) {
+    return ((s * u + i) * u + r) * u;
+  }
+  function m(u) {
+    return ((d * u + l) * u + a) * u;
+  }
+  function b(u) {
+    return (3 * s * u + 2 * i) * u + r;
+  }
+  function y(u) {
+    let c = u;
+    for (let v = 0; v < 8; v++) {
+      const M = g(c) - u;
+      if (Math.abs(M) < 1e-7) return c;
+      const I = b(c);
+      if (Math.abs(I) < 1e-7) break;
+      c -= M / I;
+    }
+    let f = 0, w = 1;
+    for (c = u; f < w; ) {
+      const v = g(c);
+      if (Math.abs(v - u) < 1e-7) return c;
+      u > v ? f = c : w = c, c = (f + w) / 2;
+    }
+    return c;
+  }
+  return (u) => u <= 0 ? 0 : u >= 1 ? 1 : m(y(u));
+}
+const ke = {
+  linear: ((e) => e),
+  ease: L(0.25, 0.1, 0.25, 1),
+  easeIn: L(0.42, 0, 1, 1),
+  easeOut: L(0, 0, 0.58, 1),
+  easeInOut: L(0.42, 0, 0.58, 1),
+  bezier: L,
+  bounce: ((e) => e < 1 / 2.75 ? 7.5625 * e * e : e < 2 / 2.75 ? 7.5625 * (e -= 1.5 / 2.75) * e + 0.75 : e < 2.5 / 2.75 ? 7.5625 * (e -= 2.25 / 2.75) * e + 0.9375 : 7.5625 * (e -= 2.625 / 2.75) * e + 0.984375),
+  elastic: (e = 1) => {
+    const n = 0.3 / Math.max(e, 1e-3);
+    return (t) => t <= 0 ? 0 : t >= 1 ? 1 : Math.pow(2, -10 * t) * Math.sin((t - n / 4) * (2 * Math.PI) / n) + 1;
+  },
+  in: (e) => e,
+  out: (e) => (n) => 1 - e(1 - n),
+  inOut: (e) => (n) => n < 0.5 ? e(n * 2) / 2 : 1 - e((1 - n) * 2) / 2
+};
+function K(e) {
+  let n = e.replace("#", "");
+  n.length === 3 && (n = n[0] + n[0] + n[1] + n[1] + n[2] + n[2]), n.length === 6 && (n += "ff");
+  const t = parseInt(n, 16);
+  return [
+    t >> 24 & 255,
+    t >> 16 & 255,
+    t >> 8 & 255,
+    (t & 255) / 255
+  ];
+}
+function Q(e) {
+  const n = e.match(
+    /rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)/
+  );
+  if (n)
+    return [
+      Number(n[1]),
+      Number(n[2]),
+      Number(n[3]),
+      n[4] !== void 0 ? Number(n[4]) : 1
+    ];
+  throw new Error(`Cannot parse color: ${e}`);
+}
+const Z = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  cyan: "#00ffff",
+  magenta: "#ff00ff",
+  orange: "#ffa500",
+  purple: "#800080",
+  pink: "#ffc0cb",
+  gray: "#808080",
+  grey: "#808080",
+  transparent: "rgba(0,0,0,0)"
+};
+function Ce(e) {
+  const n = e.trim().toLowerCase();
+  if (Z[n]) {
+    const t = Z[n];
+    return t.startsWith("#") ? K(t) : Q(t);
+  }
+  if (n.startsWith("#"))
+    return K(n);
+  if (n.startsWith("rgb"))
+    return Q(n);
+  throw new Error(`Unsupported color format: ${e}`);
+}
+function Ee(e) {
+  const [n, t, o, r] = e;
+  return r === 1 ? `rgb(${Math.round(n)}, ${Math.round(t)}, ${Math.round(o)})` : `rgba(${Math.round(n)}, ${Math.round(t)}, ${Math.round(o)}, ${Number(r.toFixed(3))})`;
+}
+function Ve(e, n, t, o) {
+  if (n.length !== t.length)
+    throw new Error("inputRange and outputRange must have the same length.");
+  const r = t.map(Ce), i = O(
+    e,
+    n,
+    r.map((d) => d[0]),
+    o
+  ), s = O(
+    e,
+    n,
+    r.map((d) => d[1]),
+    o
+  ), a = O(
+    e,
+    n,
+    r.map((d) => d[2]),
+    o
+  ), l = O(
+    e,
+    n,
+    r.map((d) => d[3]),
+    o
+  );
+  return Ee([
+    Math.max(0, Math.min(255, i)),
+    Math.max(0, Math.min(255, s)),
+    Math.max(0, Math.min(255, a)),
+    Math.max(0, Math.min(1, l))
+  ]);
+}
+let W = null;
+function Le(e) {
+  if (W !== null)
+    throw new Error("setRootComponent() can only be called once.");
+  W = e;
+}
+function De() {
+  return W;
+}
+function Oe(e) {
+  return `/${e.startsWith("/") ? e.slice(1) : e}`;
+}
+function He() {
+  return typeof window < "u" && window.__RENDIV_INPUT_PROPS__ ? window.__RENDIV_INPUT_PROPS__ : {};
+}
+function Ae() {
+  const { environment: e } = p(Y);
+  return {
+    isStudio: e === "studio",
+    isRendering: e === "rendering",
+    isPlayer: e === "player"
+  };
+}
+function ze() {
+  if (typeof window < "u") {
+    const e = window.__RENDIV_ENVIRONMENT__;
+    return {
+      isStudio: e === "studio",
+      isRendering: e === "rendering",
+      isPlayer: e === "player"
+    };
+  }
+  return { isStudio: !1, isRendering: !1, isPlayer: !1 };
+}
+const Xe = P(null);
+export {
+  ye as AnimatedImage,
+  pe as Audio,
+  Fe as Composition,
+  z as CompositionContext,
+  ee as CompositionManagerContext,
+  ke as Easing,
+  U as Fill,
+  ue as Folder,
+  A as FolderContext,
+  de as Freeze,
+  we as IFrame,
+  he as Img,
+  fe as Loop,
+  Y as RendivEnvironmentContext,
+  ne as Sequence,
+  R as SequenceContext,
+  Re as Series,
+  xe as Still,
+  x as TimelineContext,
+  Xe as TimelineRegistryContext,
+  ge as Video,
+  Te as abortRender,
+  Ve as blendColors,
+  He as getInputProps,
+  $e as getPendingHoldCount,
+  Pe as getPendingHoldLabels,
+  ze as getRendivEnvironment,
+  De as getRootComponent,
+  qe as getSpringDuration,
+  D as holdRender,
+  O as interpolate,
+  _ as releaseRender,
+  Le as setRootComponent,
+  Ie as spring,
+  Oe as staticFile,
+  _e as useCompositionConfig,
+  Ne as useFrame,
+  Ae as useRendivEnvironment
+};