@bbl-digital/snorre 4.2.92 → 4.2.94

package/dist/snorre.es695.js

@@ -0,0 +1,24 @@
+import { isDragActive as d } from "./snorre.es696.js";
+import { setupGesture as m } from "./snorre.es697.js";
+function c(n) {
+  return !(n.pointerType === "touch" || d());
+}
+function h(n, p, u = {}) {
+  const [f, r, a] = m(n, u), v = (e) => {
+    if (!c(e))
+      return;
+    const { target: t } = e, o = p(t, e);
+    if (typeof o != "function" || !t)
+      return;
+    const i = (s) => {
+      c(s) && (o(s), t.removeEventListener("pointerleave", i));
+    };
+    t.addEventListener("pointerleave", i, r);
+  };
+  return f.forEach((e) => {
+    e.addEventListener("pointerenter", v, r);
+  }), a;
+}
+export {
+  h as hover
+};

package/dist/snorre.es696.js

@@ -0,0 +1,11 @@
+const e = {
+  x: !1,
+  y: !1
+};
+function i() {
+  return e.x || e.y;
+}
+export {
+  i as isDragActive,
+  e as isDragging
+};

package/dist/snorre.es697.js

@@ -0,0 +1,12 @@
+import { resolveElements as s } from "./snorre.es880.js";
+function a(t, n) {
+  const o = s(t), e = new AbortController(), r = {
+    passive: !0,
+    ...n,
+    signal: e.signal
+  };
+  return [o, r, () => e.abort()];
+}
+export {
+  a as setupGesture
+};

package/dist/snorre.es698.js

@@ -0,0 +1,43 @@
+import { isDragActive as L } from "./snorre.es696.js";
+import { capturePointer as u } from "./snorre.es699.js";
+import { isNodeOrChild as w } from "./snorre.es700.js";
+import { isPrimaryPointer as E } from "./snorre.es701.js";
+import { setupGesture as g } from "./snorre.es697.js";
+import { isElementKeyboardAccessible as y } from "./snorre.es702.js";
+import { enableKeyboardPress as A } from "./snorre.es703.js";
+import { isPressing as c } from "./snorre.es704.js";
+function p(n) {
+  return E(n) && !L();
+}
+function k(n, o, f = {}) {
+  const [b, r, P] = g(n, f), h = (i) => {
+    const e = i.currentTarget;
+    if (!e || !p(i) || c.has(e))
+      return;
+    c.add(e), u(i, "set");
+    const s = o(e, i), d = (t, m) => {
+      e.removeEventListener("pointerup", a), e.removeEventListener("pointercancel", l), u(t, "release"), !(!p(t) || !c.has(e)) && (c.delete(e), typeof s == "function" && s(t, { success: m }));
+    }, a = (t) => {
+      (t.isTrusted ? O(t, e instanceof Element ? e.getBoundingClientRect() : {
+        left: 0,
+        top: 0,
+        right: window.innerWidth,
+        bottom: window.innerHeight
+      }) : !1) ? d(t, !1) : d(t, !(e instanceof Element) || w(e, t.target));
+    }, l = (t) => {
+      d(t, !1);
+    };
+    e.addEventListener("pointerup", a, r), e.addEventListener("pointercancel", l, r), e.addEventListener("lostpointercapture", l, r);
+  };
+  return b.forEach((i) => {
+    i = f.useGlobalTarget ? window : i;
+    let e = !1;
+    i instanceof HTMLElement && (e = !0, !y(i) && i.getAttribute("tabindex") === null && (i.tabIndex = 0)), i.addEventListener("pointerdown", h, r), e && i.addEventListener("focus", (s) => A(s, r), r);
+  }), P;
+}
+function O(n, o) {
+  return n.clientX < o.left || n.clientX > o.right || n.clientY < o.top || n.clientY > o.bottom;
+}
+export {
+  k as press
+};

package/dist/snorre.es699.js

@@ -0,0 +1,11 @@
+function a(t, i) {
+  const r = `${i}PointerCapture`;
+  if (t.target instanceof Element && r in t.target && t.pointerId !== void 0)
+    try {
+      t.target[r](t.pointerId);
+    } catch {
+    }
+}
+export {
+  a as capturePointer
+};

package/dist/snorre.es7.js

@@ -0,0 +1,27 @@
+import { jsx as m } from "./snorre.es335.js";
+import r from "./snorre.es341.js";
+const p = ({
+  className: s,
+  color: i,
+  subtle: l,
+  margin: t,
+  height: e,
+  lightGray: a,
+  css: o
+}) => /* @__PURE__ */ m(
+  "hr",
+  {
+    className: s,
+    css: (f) => [
+      r.default(i),
+      l && r.subtle(f),
+      t && r.margin(t),
+      e && r.height(e),
+      a && r.lightGray,
+      o && o
+    ]
+  }
+);
+export {
+  p as default
+};

package/dist/snorre.es70.js

@@ -0,0 +1,6 @@
+import { j as r } from "./snorre.es333.js";
+import t from "./snorre.es364.js";
+const s = (o) => /* @__PURE__ */ r.jsx("svg", { viewBox: "0 0 24 24", ...o, children: /* @__PURE__ */ r.jsx("path", { d: "M12,2 C6.48,2 2,6.48 2,12 C2,17.52 6.48,22 12,22 C17.52,22 22,17.52 22,12 C22,6.48 17.52,2 12,2 Z M13,17 L11,17 L11,15 L13,15 L13,17 Z M13,13 L11,13 L11,7 L13,7 L13,13 Z" }) }), n = t()(s);
+export {
+  n as default
+};

package/dist/snorre.es700.js

@@ -0,0 +1,4 @@
+const t = (r, e) => e ? r === e ? !0 : t(r, e.parentElement) : !1;
+export {
+  t as isNodeOrChild
+};

package/dist/snorre.es701.js

@@ -0,0 +1,4 @@
+const o = (r) => r.pointerType === "mouse" ? typeof r.button != "number" || r.button <= 0 : r.isPrimary !== !1;
+export {
+  o as isPrimaryPointer
+};

package/dist/snorre.es702.js

@@ -0,0 +1,13 @@
+const t = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function n(e) {
+  return t.has(e.tagName) || e.tabIndex !== -1;
+}
+export {
+  n as isElementKeyboardAccessible
+};

package/dist/snorre.es703.js

@@ -0,0 +1,27 @@
+import { isPressing as u } from "./snorre.es704.js";
+function d(r) {
+  return (n) => {
+    n.key === "Enter" && r(n);
+  };
+}
+function t(r, n) {
+  r.dispatchEvent(new PointerEvent("pointer" + n, { isPrimary: !0, bubbles: !0 }));
+}
+const c = (r, n) => {
+  const e = r.currentTarget;
+  if (!e)
+    return;
+  const i = d(() => {
+    if (u.has(e))
+      return;
+    t(e, "down");
+    const s = d(() => {
+      t(e, "up");
+    }), o = () => t(e, "cancel");
+    e.addEventListener("keyup", s, n), e.addEventListener("blur", o, n);
+  });
+  e.addEventListener("keydown", i, n), e.addEventListener("blur", () => e.removeEventListener("keydown", i), n);
+};
+export {
+  c as enableKeyboardPress
+};

package/dist/snorre.es704.js

@@ -0,0 +1,4 @@
+const e = /* @__PURE__ */ new WeakSet();
+export {
+  e as isPressing
+};

package/dist/snorre.es705.js

@@ -0,0 +1,7 @@
+const n = /* @__NO_SIDE_EFFECTS__ */ (e, o, t) => {
+  const r = o - e;
+  return r === 0 ? 1 : (t - e) / r;
+};
+export {
+  n as progress
+};

package/dist/snorre.es706.js

@@ -0,0 +1,6 @@
+function n(c, e) {
+  return e ? c * (1e3 / e) : 0;
+}
+export {
+  n as velocityPerSecond
+};

package/dist/snorre.es707.js

@@ -0,0 +1,7 @@
+import { cubicBezier as e } from "./snorre.es715.js";
+const o = /* @__PURE__ */ e(0.42, 0, 1, 1), s = /* @__PURE__ */ e(0, 0, 0.58, 1), c = /* @__PURE__ */ e(0.42, 0, 0.58, 1);
+export {
+  o as easeIn,
+  c as easeInOut,
+  s as easeOut
+};

package/dist/snorre.es708.js

@@ -0,0 +1,4 @@
+const n = (r) => Array.isArray(r) && typeof r[0] != "number";
+export {
+  n as isEasingArray
+};

package/dist/snorre.es709.js

@@ -0,0 +1,32 @@
+import { invariant as t } from "./snorre.es624.js";
+import { noop as i } from "./snorre.es608.js";
+import { isBezierDefinition as m } from "./snorre.es851.js";
+import { anticipate as u } from "./snorre.es614.js";
+import { backOut as s, backInOut as p, backIn as f } from "./snorre.es615.js";
+import { circOut as I, circInOut as b, circIn as l } from "./snorre.es616.js";
+import { cubicBezier as O } from "./snorre.es715.js";
+import { easeOut as g, easeInOut as y, easeIn as k } from "./snorre.es707.js";
+const e = {
+  linear: i,
+  easeIn: k,
+  easeInOut: y,
+  easeOut: g,
+  circIn: l,
+  circInOut: b,
+  circOut: I,
+  backIn: f,
+  backInOut: p,
+  backOut: s,
+  anticipate: u
+}, L = (r) => {
+  if (m(r)) {
+    t(r.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    const [o, a, n, c] = r;
+    return O(o, a, n, c);
+  } else if (typeof r == "string")
+    return t(e[r] !== void 0, `Invalid easing type '${r}'`), e[r];
+  return r;
+};
+export {
+  L as easingDefinitionToFunction
+};

package/dist/snorre.es71.js

@@ -0,0 +1,6 @@
+import { j as L } from "./snorre.es333.js";
+import n from "./snorre.es364.js";
+const o = (t) => /* @__PURE__ */ L.jsx("svg", { viewBox: "0 0 24 24", ...t, children: /* @__PURE__ */ L.jsx("path", { d: "M19,19 L5,19 L5,5 L12,5 L12,3 L3,3 L3,21 L21,21 L21,12 L19,12 L19,19 Z M14,3 L14,5 L17.59,5 L7.76,14.83 L9.17,16.24 L19,6.41 L19,10 L21,10 L21,3 L14,3 Z" }) }), e = n()(o);
+export {
+  e as default
+};

package/dist/snorre.es710.js

@@ -0,0 +1,41 @@
+import { invariant as h } from "./snorre.es624.js";
+import { noop as x } from "./snorre.es608.js";
+import { progress as y } from "./snorre.es705.js";
+import { clamp as M } from "./snorre.es627.js";
+import { mix as b } from "./snorre.es628.js";
+import { pipe as A } from "./snorre.es629.js";
+function F(r, e, c) {
+  const t = [], f = c || b, n = r.length - 1;
+  for (let o = 0; o < n; o++) {
+    let s = f(r[o], r[o + 1]);
+    if (e) {
+      const a = Array.isArray(e) ? e[o] || x : e;
+      s = A(a, s);
+    }
+    t.push(s);
+  }
+  return t;
+}
+function I(r, e, { clamp: c = !0, ease: t, mixer: f } = {}) {
+  const n = r.length;
+  if (h(n === e.length, "Both input and output ranges must be the same length"), n === 1)
+    return () => e[0];
+  if (n === 2 && e[0] === e[1])
+    return () => e[1];
+  const o = r[0] === r[1];
+  r[0] > r[n - 1] && (r = [...r].reverse(), e = [...e].reverse());
+  const s = F(e, t, f), a = s.length, l = (m) => {
+    if (o && m < r[0])
+      return e[0];
+    let i = 0;
+    if (a > 1)
+      for (; i < r.length - 2 && !(m < r[i + 1]); i++)
+        ;
+    const g = y(r[i], r[i + 1], m);
+    return s[i](g);
+  };
+  return c ? (m) => l(M(r[0], r[n - 1], m)) : l;
+}
+export {
+  I as interpolate
+};

package/dist/snorre.es711.js

@@ -0,0 +1,8 @@
+import { fillOffset as e } from "./snorre.es884.js";
+function n(t) {
+  const f = [0];
+  return e(f, t.length - 1), f;
+}
+export {
+  n as defaultOffset
+};

package/dist/snorre.es712.js

@@ -0,0 +1,6 @@
+function o(e, t) {
+  return e.map((n) => n * t);
+}
+export {
+  o as convertOffsetToTimes
+};

package/dist/snorre.es713.js

@@ -0,0 +1,52 @@
+import { mixNumber as h } from "./snorre.es714.js";
+import { mixColor as u } from "./snorre.es885.js";
+import { pipe as b } from "./snorre.es629.js";
+import { warning as y } from "./snorre.es624.js";
+import { color as m } from "./snorre.es676.js";
+import { complex as v, analyseComplexValue as a } from "./snorre.es668.js";
+import { isCSSVariableToken as g } from "./snorre.es652.js";
+import { invisibleValues as c, mixVisibility as V } from "./snorre.es886.js";
+import { mixImmediate as l } from "./snorre.es887.js";
+function C(e, t) {
+  return (r) => h(e, t, r);
+}
+function f(e) {
+  return typeof e == "number" ? C : typeof e == "string" ? g(e) ? l : m.test(e) ? u : S : Array.isArray(e) ? p : typeof e == "object" ? m.test(e) ? u : k : l;
+}
+function p(e, t) {
+  const r = [...e], o = r.length, n = e.map((i, s) => f(i)(i, t[s]));
+  return (i) => {
+    for (let s = 0; s < o; s++)
+      r[s] = n[s](i);
+    return r;
+  };
+}
+function k(e, t) {
+  const r = { ...e, ...t }, o = {};
+  for (const n in r)
+    e[n] !== void 0 && t[n] !== void 0 && (o[n] = f(e[n])(e[n], t[n]));
+  return (n) => {
+    for (const i in o)
+      r[i] = o[i](n);
+    return r;
+  };
+}
+function I(e, t) {
+  var r;
+  const o = [], n = { color: 0, var: 0, number: 0 };
+  for (let i = 0; i < t.values.length; i++) {
+    const s = t.types[i], x = e.indexes[s][n[s]], d = (r = e.values[x]) !== null && r !== void 0 ? r : 0;
+    o[i] = d, n[s]++;
+  }
+  return o;
+}
+const S = (e, t) => {
+  const r = v.createTransformer(t), o = a(e), n = a(t);
+  return o.indexes.var.length === n.indexes.var.length && o.indexes.color.length === n.indexes.color.length && o.indexes.number.length >= n.indexes.number.length ? c.has(e) && !n.values.length || c.has(t) && !o.values.length ? V(e, t) : b(p(I(o, n), n.values), r) : (y(!0, `Complex values '${e}' and '${t}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`), l(e, t));
+};
+export {
+  f as getMixer,
+  p as mixArray,
+  S as mixComplex,
+  k as mixObject
+};

package/dist/snorre.es714.js

@@ -0,0 +1,4 @@
+const n = (e, r, t) => e + (r - e) * t;
+export {
+  n as mixNumber
+};

package/dist/snorre.es715.js

@@ -0,0 +1,18 @@
+import { noop as b } from "./snorre.es608.js";
+const s = (n, i, r) => (((1 - 3 * r + 3 * i) * n + (3 * r - 6 * i)) * n + 3 * i) * n, f = 1e-7, l = 12;
+function a(n, i, r, c, o) {
+  let e, t, u = 0;
+  do
+    t = i + (r - i) / 2, e = s(t, c, o) - n, e > 0 ? r = t : i = t;
+  while (Math.abs(e) > f && ++u < l);
+  return t;
+}
+function d(n, i, r, c) {
+  if (n === i && r === c)
+    return b;
+  const o = (e) => a(e, 0, 1, n, r);
+  return (e) => e === 0 || e === 1 ? e : s(o(e), i, c);
+}
+export {
+  d as cubicBezier
+};

package/dist/snorre.es716.js

@@ -0,0 +1,4 @@
+const t = (o) => (r) => r <= 0.5 ? o(2 * r) / 2 : (2 - o(2 * (1 - r))) / 2;
+export {
+  t as mirrorEasing
+};

package/dist/snorre.es717.js

@@ -0,0 +1,4 @@
+const s = (e) => (r) => 1 - e(1 - r);
+export {
+  s as reverseEasing
+};

package/dist/snorre.es718.js

@@ -0,0 +1,26 @@
+import { stepsOrder as c } from "./snorre.es888.js";
+import { createRenderStep as M } from "./snorre.es889.js";
+const w = 40;
+function S(o, p) {
+  let r = !1, a = !0;
+  const e = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  }, l = () => r = !0, n = c.reduce((s, t) => (s[t] = M(l, p ? t : void 0), s), {}), { read: u, resolveKeyframes: f, update: m, preRender: d, render: g, postRender: h } = n, i = () => {
+    const s = performance.now();
+    r = !1, e.delta = a ? 1e3 / 60 : Math.max(Math.min(s - e.timestamp, w), 1), e.timestamp = s, e.isProcessing = !0, u.process(e), f.process(e), m.process(e), d.process(e), g.process(e), h.process(e), e.isProcessing = !1, r && p && (a = !1, o(i));
+  }, R = () => {
+    r = !0, a = !0, e.isProcessing || o(i);
+  };
+  return { schedule: c.reduce((s, t) => {
+    const x = n[t];
+    return s[t] = (P, E = !1, F = !1) => (r || R(), x.schedule(P, E, F)), s;
+  }, {}), cancel: (s) => {
+    for (let t = 0; t < c.length; t++)
+      n[c[t]].cancel(s);
+  }, state: e, steps: n };
+}
+export {
+  S as createRenderBatcher
+};

package/dist/snorre.es719.js

@@ -0,0 +1,9 @@
+const s = (t, n) => Math.abs(t - n);
+function e(t, n) {
+  const a = s(t.x, n.x), c = s(t.y, n.y);
+  return Math.sqrt(a ** 2 + c ** 2);
+}
+export {
+  s as distance,
+  e as distance2D
+};

package/dist/snorre.es72.js

@@ -0,0 +1,6 @@
+import { j as o } from "./snorre.es333.js";
+import t from "./snorre.es364.js";
+const r = (C) => /* @__PURE__ */ o.jsx("svg", { viewBox: "0 0 24 24", ...C, children: /* @__PURE__ */ o.jsx("path", { d: "M12,4.5 C7,4.5 2.73,7.61 1,12 C2.73,16.39 7,19.5 12,19.5 C17,19.5 21.27,16.39 23,12 C21.27,7.61 17,4.5 12,4.5 Z M12,17 C9.24,17 7,14.76 7,12 C7,9.24 9.24,7 12,7 C14.76,7 17,9.24 17,12 C17,14.76 14.76,17 12,17 Z M12,9 C10.34,9 9,10.34 9,12 C9,13.66 10.34,15 12,15 C13.66,15 15,13.66 15,12 C15,10.34 13.66,9 12,9 Z" }) }), n = t()(r);
+export {
+  n as default
+};

package/dist/snorre.es720.js

@@ -0,0 +1,13 @@
+import { AnimationFeature as t } from "./snorre.es721.js";
+import { ExitAnimationFeature as i } from "./snorre.es722.js";
+const o = {
+  animation: {
+    Feature: t
+  },
+  exit: {
+    Feature: i
+  }
+};
+export {
+  o as animations
+};

package/dist/snorre.es721.js

@@ -0,0 +1,34 @@
+import { isAnimationControls as o } from "./snorre.es726.js";
+import { createAnimationState as n } from "./snorre.es890.js";
+import { Feature as a } from "./snorre.es891.js";
+class u extends a {
+  /**
+   * We dynamically generate the AnimationState manager as it contains a reference
+   * to the underlying animation library. We only want to load that if we load this,
+   * so people can optionally code split it out using the `m` component.
+   */
+  constructor(t) {
+    super(t), t.animationState || (t.animationState = n(t));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.node.getProps();
+    o(t) && (this.unmountControls = t.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: t } = this.node.getProps(), { animate: i } = this.node.prevProps || {};
+    t !== i && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    var t;
+    this.node.animationState.reset(), (t = this.unmountControls) === null || t === void 0 || t.call(this);
+  }
+}
+export {
+  u as AnimationFeature
+};

package/dist/snorre.es722.js

@@ -0,0 +1,27 @@
+import { Feature as s } from "./snorre.es891.js";
+let o = 0;
+class d extends s {
+  constructor() {
+    super(...arguments), this.id = o++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: t, onExitComplete: e } = this.node.presenceContext, { isPresent: n } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || t === n)
+      return;
+    const i = this.node.animationState.setActive("exit", !t);
+    e && !t && i.then(() => {
+      e(this.id);
+    });
+  }
+  mount() {
+    const { register: t, onExitComplete: e } = this.node.presenceContext || {};
+    e && e(this.id), t && (this.unmount = t(this.id));
+  }
+  unmount() {
+  }
+}
+export {
+  d as ExitAnimationFeature
+};

package/dist/snorre.es723.js

@@ -0,0 +1,36 @@
+import { mixNumber as m } from "./snorre.es714.js";
+const N = 1e-4, u = 1 - N, E = 1 + N, R = 0.01, S = 0 - R, a = 0 + R;
+function s(n) {
+  return n.max - n.min;
+}
+function L(n, i, c) {
+  return Math.abs(n - i) <= c;
+}
+function x(n, i, c, o = 0.5) {
+  n.origin = o, n.originPoint = m(i.min, i.max, n.origin), n.scale = s(c) / s(i), n.translate = m(c.min, c.max, n.origin) - n.originPoint, (n.scale >= u && n.scale <= E || isNaN(n.scale)) && (n.scale = 1), (n.translate >= S && n.translate <= a || isNaN(n.translate)) && (n.translate = 0);
+}
+function I(n, i, c, o) {
+  x(n.x, i.x, c.x, o ? o.originX : void 0), x(n.y, i.y, c.y, o ? o.originY : void 0);
+}
+function A(n, i, c) {
+  n.min = c.min + i.min, n.max = n.min + s(i);
+}
+function P(n, i, c) {
+  A(n.x, i.x, c.x), A(n.y, i.y, c.y);
+}
+function f(n, i, c) {
+  n.min = i.min - c.min, n.max = n.min + s(i);
+}
+function T(n, i, c) {
+  f(n.x, i.x, c.x), f(n.y, i.y, c.y);
+}
+export {
+  x as calcAxisDelta,
+  I as calcBoxDelta,
+  s as calcLength,
+  A as calcRelativeAxis,
+  f as calcRelativeAxisPosition,
+  P as calcRelativeBox,
+  T as calcRelativePosition,
+  L as isNear
+};

package/dist/snorre.es724.js

@@ -0,0 +1,20 @@
+import { isValidMotionProp as e } from "./snorre.es650.js";
+let n = (t) => !e(t);
+function f(t) {
+  t && (n = (o) => o.startsWith("on") ? !e(o) : t(o));
+}
+try {
+  f(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function u(t, o, a) {
+  const i = {};
+  for (const r in t)
+    r === "values" && typeof t.values == "object" || (n(r) || a === !0 && e(r) || !o && !e(r) || // If trying to use native HTML drag events, forward drag listeners
+    t.draggable && r.startsWith("onDrag")) && (i[r] = t[r]);
+  return i;
+}
+export {
+  u as filterProps,
+  f as loadExternalIsValidProp
+};

package/dist/snorre.es725.js

@@ -0,0 +1,53 @@
+import { useContext as C } from "react";
+import { isAnimationControls as x } from "./snorre.es726.js";
+import { MotionContext as S } from "./snorre.es642.js";
+import { PresenceContext as h } from "./snorre.es638.js";
+import { isControllingVariants as M, isVariantNode as N } from "./snorre.es671.js";
+import { resolveVariantFromProps as P } from "./snorre.es673.js";
+import { useConstant as T } from "./snorre.es597.js";
+import { resolveMotionValue as $ } from "./snorre.es604.js";
+function b({ scrapeMotionValuesFromProps: t, createRenderState: e, onUpdate: i }, s, o, r) {
+  const n = {
+    latestValues: B(s, o, r, t),
+    renderState: e()
+  };
+  return i && (n.onMount = (a) => i({ props: s, current: a, ...n }), n.onUpdate = (a) => i(a)), n;
+}
+const G = (t) => (e, i) => {
+  const s = C(S), o = C(h), r = () => b(t, e, s, o);
+  return i ? r() : T(r);
+};
+function B(t, e, i, s) {
+  const o = {}, r = s(t, {});
+  for (const m in r)
+    o[m] = $(r[m]);
+  let { initial: n, animate: a } = t;
+  const g = M(t), v = N(t);
+  e && v && !g && t.inherit !== !1 && (n === void 0 && (n = e.initial), a === void 0 && (a = e.animate));
+  let u = i ? i.initial === !1 : !1;
+  u = u || n === !1;
+  const l = u ? a : n;
+  if (l && typeof l != "boolean" && !x(l)) {
+    const m = Array.isArray(l) ? l : [l];
+    for (let d = 0; d < m.length; d++) {
+      const V = P(t, m[d]);
+      if (V) {
+        const { transitionEnd: k, transition: E, ...y } = V;
+        for (const c in y) {
+          let f = y[c];
+          if (Array.isArray(f)) {
+            const A = u ? f.length - 1 : 0;
+            f = f[A];
+          }
+          f !== null && (o[c] = f);
+        }
+        for (const c in k)
+          o[c] = k[c];
+      }
+    }
+  }
+  return o;
+}
+export {
+  G as makeUseVisualState
+};