@bbl-digital/snorre 4.2.87 → 4.2.88

package/dist/snorre.es791.js

@@ -1,52 +1,256 @@
-import N from "./snorre.es520.js";
-import b from "./snorre.es1135.js";
-import j from "./snorre.es1134.js";
-import i from "./snorre.es1136.js";
-import A from "./snorre.es1137.js";
-import B from "./snorre.es1138.js";
-import I from "./snorre.es1139.js";
-import L from "./snorre.es1140.js";
-var W = ["pure", "areStatesEqual", "areOwnPropsEqual", "areStatePropsEqual", "areMergedPropsEqual"];
-function c(e, r, p) {
-  for (var a = r.length - 1; a >= 0; a--) {
-    var t = r[a](e);
-    if (t) return t;
-  }
-  return function(u, s) {
-    throw new Error("Invalid value of type " + typeof e + " for " + p + " argument when connecting component " + s.wrappedComponentName + ".");
-  };
+import { invariant as L } from "./snorre.es621.js";
+import { setDragLock as M } from "./snorre.es940.js";
+import { animateMotionValue as S } from "./snorre.es759.js";
+import { addDomEvent as B } from "./snorre.es725.js";
+import { addPointerEvent as k } from "./snorre.es724.js";
+import { extractEventInfo as j } from "./snorre.es726.js";
+import { convertBoxToBoundingBox as T, convertBoundingBoxToBox as w } from "./snorre.es941.js";
+import { calcLength as b } from "./snorre.es720.js";
+import { createBox as R } from "./snorre.es657.js";
+import { eachAxis as u } from "./snorre.es929.js";
+import { measurePageBox as W } from "./snorre.es798.js";
+import { getContextWindow as _ } from "./snorre.es792.js";
+import { isRefObject as D } from "./snorre.es761.js";
+import { mixNumber as V } from "./snorre.es711.js";
+import { percent as O } from "./snorre.es680.js";
+import { addValueToWillChange as x } from "./snorre.es757.js";
+import { PanSession as U } from "./snorre.es793.js";
+import { applyConstraints as z, calcRelativeConstraints as I, resolveDragElastic as F, calcViewportConstraints as K, defaultElastic as N, rebaseAxisConstraints as $, calcOrigin as q } from "./snorre.es942.js";
+import { frame as C } from "./snorre.es671.js";
+const G = /* @__PURE__ */ new WeakMap();
+class ft {
+  constructor(t) {
+    this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = { x: 0, y: 0 }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = R(), this.visualElement = t;
+  }
+  start(t, { snapToCursor: s = !1 } = {}) {
+    const { presenceContext: i } = this.visualElement;
+    if (i && i.isPresent === !1)
+      return;
+    const n = (o) => {
+      const { dragSnapToOrigin: a } = this.getProps();
+      a ? this.pauseAnimation() : this.stopAnimation(), s && this.snapToCursor(j(o).point);
+    }, r = (o, a) => {
+      const { drag: f, dragPropagation: d, onDragStart: g } = this.getProps();
+      if (f && !d && (this.openDragLock && this.openDragLock(), this.openDragLock = M(f), !this.openDragLock))
+        return;
+      this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), u((m) => {
+        let E = this.getAxisMotionValue(m).get() || 0;
+        if (O.test(E)) {
+          const { projection: A } = this.visualElement;
+          if (A && A.layout) {
+            const y = A.layout.layoutBox[m];
+            y && (E = b(y) * (parseFloat(E) / 100));
+          }
+        }
+        this.originPoint[m] = E;
+      }), g && C.postRender(() => g(o, a)), x(this.visualElement, "transform");
+      const { animationState: v } = this.visualElement;
+      v && v.setActive("whileDrag", !0);
+    }, e = (o, a) => {
+      const { dragPropagation: f, dragDirectionLock: d, onDirectionLock: g, onDrag: v } = this.getProps();
+      if (!f && !this.openDragLock)
+        return;
+      const { offset: m } = a;
+      if (d && this.currentDirection === null) {
+        this.currentDirection = H(m), this.currentDirection !== null && g && g(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", a.point, m), this.updateAxis("y", a.point, m), this.visualElement.render(), v && v(o, a);
+    }, l = (o, a) => this.stop(o, a), c = () => u((o) => {
+      var a;
+      return this.getAnimationState(o) === "paused" && ((a = this.getAxisMotionValue(o).animation) === null || a === void 0 ? void 0 : a.play());
+    }), { dragSnapToOrigin: h } = this.getProps();
+    this.panSession = new U(t, {
+      onSessionStart: n,
+      onStart: r,
+      onMove: e,
+      onSessionEnd: l,
+      resumeAnimation: c
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: h,
+      contextWindow: _(this.visualElement)
+    });
+  }
+  stop(t, s) {
+    const i = this.isDragging;
+    if (this.cancel(), !i)
+      return;
+    const { velocity: n } = s;
+    this.startAnimation(n);
+    const { onDragEnd: r } = this.getProps();
+    r && C.postRender(() => r(t, s));
+  }
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: s } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.panSession && this.panSession.end(), this.panSession = void 0;
+    const { dragPropagation: i } = this.getProps();
+    !i && this.openDragLock && (this.openDragLock(), this.openDragLock = null), s && s.setActive("whileDrag", !1);
+  }
+  updateAxis(t, s, i) {
+    const { drag: n } = this.getProps();
+    if (!i || !P(t, n, this.currentDirection))
+      return;
+    const r = this.getAxisMotionValue(t);
+    let e = this.originPoint[t] + i[t];
+    this.constraints && this.constraints[t] && (e = z(e, this.constraints[t], this.elastic[t])), r.set(e);
+  }
+  resolveConstraints() {
+    var t;
+    const { dragConstraints: s, dragElastic: i } = this.getProps(), n = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : (t = this.visualElement.projection) === null || t === void 0 ? void 0 : t.layout, r = this.constraints;
+    s && D(s) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : s && n ? this.constraints = I(n.layoutBox, s) : this.constraints = !1, this.elastic = F(i), r !== this.constraints && n && this.constraints && !this.hasMutatedConstraints && u((e) => {
+      this.constraints !== !1 && this.getAxisMotionValue(e) && (this.constraints[e] = $(n.layoutBox[e], this.constraints[e]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: s } = this.getProps();
+    if (!t || !D(t))
+      return !1;
+    const i = t.current;
+    L(i !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.");
+    const { projection: n } = this.visualElement;
+    if (!n || !n.layout)
+      return !1;
+    const r = W(i, n.root, this.visualElement.getTransformPagePoint());
+    let e = K(n.layout.layoutBox, r);
+    if (s) {
+      const l = s(T(e));
+      this.hasMutatedConstraints = !!l, l && (e = w(l));
+    }
+    return e;
+  }
+  startAnimation(t) {
+    const { drag: s, dragMomentum: i, dragElastic: n, dragTransition: r, dragSnapToOrigin: e, onDragTransitionEnd: l } = this.getProps(), c = this.constraints || {}, h = u((o) => {
+      if (!P(o, s, this.currentDirection))
+        return;
+      let a = c && c[o] || {};
+      e && (a = { min: 0, max: 0 });
+      const f = n ? 200 : 1e6, d = n ? 40 : 1e7, g = {
+        type: "inertia",
+        velocity: i ? t[o] : 0,
+        bounceStiffness: f,
+        bounceDamping: d,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...r,
+        ...a
+      };
+      return this.startAxisValueAnimation(o, g);
+    });
+    return Promise.all(h).then(l);
+  }
+  startAxisValueAnimation(t, s) {
+    const i = this.getAxisMotionValue(t);
+    return x(this.visualElement, t), i.start(S(t, i, 0, s, this.visualElement, !1));
+  }
+  stopAnimation() {
+    u((t) => this.getAxisMotionValue(t).stop());
+  }
+  pauseAnimation() {
+    u((t) => {
+      var s;
+      return (s = this.getAxisMotionValue(t).animation) === null || s === void 0 ? void 0 : s.pause();
+    });
+  }
+  getAnimationState(t) {
+    var s;
+    return (s = this.getAxisMotionValue(t).animation) === null || s === void 0 ? void 0 : s.state;
+  }
+  /**
+   * Drag works differently depending on which props are provided.
+   *
+   * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+   * - Otherwise, we apply the delta to the x/y motion values.
+   */
+  getAxisMotionValue(t) {
+    const s = `_drag${t.toUpperCase()}`, i = this.visualElement.getProps(), n = i[s];
+    return n || this.visualElement.getValue(t, (i.initial ? i.initial[t] : void 0) || 0);
+  }
+  snapToCursor(t) {
+    u((s) => {
+      const { drag: i } = this.getProps();
+      if (!P(s, i, this.currentDirection))
+        return;
+      const { projection: n } = this.visualElement, r = this.getAxisMotionValue(s);
+      if (n && n.layout) {
+        const { min: e, max: l } = n.layout.layoutBox[s];
+        r.set(t[s] - V(e, l, 0.5));
+      }
+    });
+  }
+  /**
+   * When the viewport resizes we want to check if the measured constraints
+   * have changed and, if so, reposition the element within those new constraints
+   * relative to where it was before the resize.
+   */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current)
+      return;
+    const { drag: t, dragConstraints: s } = this.getProps(), { projection: i } = this.visualElement;
+    if (!D(s) || !i || !this.constraints)
+      return;
+    this.stopAnimation();
+    const n = { x: 0, y: 0 };
+    u((e) => {
+      const l = this.getAxisMotionValue(e);
+      if (l && this.constraints !== !1) {
+        const c = l.get();
+        n[e] = q({ min: c, max: c }, this.constraints[e]);
+      }
+    });
+    const { transformTemplate: r } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = r ? r({}, "") : "none", i.root && i.root.updateScroll(), i.updateLayout(), this.resolveConstraints(), u((e) => {
+      if (!P(e, t, null))
+        return;
+      const l = this.getAxisMotionValue(e), { min: c, max: h } = this.constraints[e];
+      l.set(V(c, h, n[e]));
+    });
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    G.set(this.visualElement, this);
+    const t = this.visualElement.current, s = k(t, "pointerdown", (c) => {
+      const { drag: h, dragListener: o = !0 } = this.getProps();
+      h && o && this.start(c);
+    }), i = () => {
+      const { dragConstraints: c } = this.getProps();
+      D(c) && c.current && (this.constraints = this.resolveRefConstraints());
+    }, { projection: n } = this.visualElement, r = n.addEventListener("measure", i);
+    n && !n.layout && (n.root && n.root.updateScroll(), n.updateLayout()), C.read(i);
+    const e = B(window, "resize", () => this.scalePositionWithinConstraints()), l = n.addEventListener("didUpdate", ({ delta: c, hasLayoutChanged: h }) => {
+      this.isDragging && h && (u((o) => {
+        const a = this.getAxisMotionValue(o);
+        a && (this.originPoint[o] += c[o].translate, a.set(a.get() + c[o].translate));
+      }), this.visualElement.render());
+    });
+    return () => {
+      e(), s(), r(), l && l();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: s = !1, dragDirectionLock: i = !1, dragPropagation: n = !1, dragConstraints: r = !1, dragElastic: e = N, dragMomentum: l = !0 } = t;
+    return {
+      ...t,
+      drag: s,
+      dragDirectionLock: i,
+      dragPropagation: n,
+      dragConstraints: r,
+      dragElastic: e,
+      dragMomentum: l
+    };
+  }
 }
-function k(e, r) {
-  return e === r;
+function P(p, t, s) {
+  return (t === !0 || t === p) && (s === null || s === p);
 }
-function z(e) {
-  var r = e === void 0 ? {} : e, p = r.connectHOC, a = p === void 0 ? j : p, t = r.mapStateToPropsFactories, u = t === void 0 ? B : t, s = r.mapDispatchToPropsFactories, S = s === void 0 ? A : s, l = r.mergePropsFactories, g = l === void 0 ? I : l, P = r.selectorFactory, h = P === void 0 ? L : P;
-  return function(m, F, M, n) {
-    n === void 0 && (n = {});
-    var o = n, f = o.pure, T = f === void 0 ? !0 : f, d = o.areStatesEqual, _ = d === void 0 ? k : d, v = o.areOwnPropsEqual, w = v === void 0 ? i : v, E = o.areStatePropsEqual, $ = E === void 0 ? i : E, q = o.areMergedPropsEqual, D = q === void 0 ? i : q, O = b(o, W), y = c(m, u, "mapStateToProps"), C = c(F, S, "mapDispatchToProps"), x = c(M, g, "mergeProps");
-    return a(h, N({
-      // used in error messages
-      methodName: "connect",
-      // used to compute Connect's displayName from the wrapped component's displayName.
-      getDisplayName: function(H) {
-        return "Connect(" + H + ")";
-      },
-      // if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes
-      shouldHandleStateChanges: !!m,
-      // passed through to selectorFactory
-      initMapStateToProps: y,
-      initMapDispatchToProps: C,
-      initMergeProps: x,
-      pure: T,
-      areStatesEqual: _,
-      areOwnPropsEqual: w,
-      areStatePropsEqual: $,
-      areMergedPropsEqual: D
-    }, O));
-  };
+function H(p, t = 10) {
+  let s = null;
+  return Math.abs(p.y) > t ? s = "y" : Math.abs(p.x) > t && (s = "x"), s;
 }
-const rr = /* @__PURE__ */ z();
 export {
-  z as createConnect,
-  rr as default
+  ft as VisualElementDragControls,
+  G as elementDragControls
 };

package/dist/snorre.es792.js

@@ -1,38 +1,4 @@
-import p, { useMemo as s } from "react";
-import r from "./snorre.es550.js";
-import { ReactReduxContext as f } from "./snorre.es794.js";
-import { createSubscription as d } from "./snorre.es1132.js";
-import { useIsomorphicLayoutEffect as b } from "./snorre.es1133.js";
-function m(o) {
-  var e = o.store, u = o.context, c = o.children, n = s(function() {
-    var t = d(e);
-    return {
-      store: e,
-      subscription: t
-    };
-  }, [e]), i = s(function() {
-    return e.getState();
-  }, [e]);
-  b(function() {
-    var t = n.subscription;
-    return t.onStateChange = t.notifyNestedSubs, t.trySubscribe(), i !== e.getState() && t.notifyNestedSubs(), function() {
-      t.tryUnsubscribe(), t.onStateChange = null;
-    };
-  }, [n, i]);
-  var a = u || f;
-  return /* @__PURE__ */ p.createElement(a.Provider, {
-    value: n
-  }, c);
-}
-process.env.NODE_ENV !== "production" && (m.propTypes = {
-  store: r.shape({
-    subscribe: r.func.isRequired,
-    dispatch: r.func.isRequired,
-    getState: r.func.isRequired
-  }),
-  context: r.object,
-  children: r.any
-});
+const t = ({ current: e }) => e ? e.ownerDocument.defaultView : null;
 export {
-  m as default
+  t as getContextWindow
 };

package/dist/snorre.es793.js

@@ -1,8 +1,84 @@
-import { __module as r } from "./snorre.es1198.js";
-import { __require as e } from "./snorre.es1199.js";
-import { __require as o } from "./snorre.es1200.js";
-process.env.NODE_ENV === "production" ? r.exports = e() : r.exports = o();
-var i = r.exports;
+import { secondsToMilliseconds as w, millisecondsToSeconds as S } from "./snorre.es606.js";
+import { isPrimaryPointer as D } from "./snorre.es698.js";
+import { addPointerEvent as d } from "./snorre.es724.js";
+import { extractEventInfo as T } from "./snorre.es726.js";
+import { distance2D as W } from "./snorre.es716.js";
+import { pipe as L } from "./snorre.es626.js";
+import { frameData as x, frame as U, cancelFrame as O } from "./snorre.es671.js";
+class B {
+  constructor(n, o, { transformPagePoint: e, contextWindow: r, dragSnapToOrigin: h = !1 } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const i = p(this.lastMoveEventInfo, this.history), a = this.startEvent !== null, c = W(i.offset, { x: 0, y: 0 }) >= 3;
+      if (!a && !c)
+        return;
+      const { point: f } = i, { timestamp: m } = x;
+      this.history.push({ ...f, timestamp: m });
+      const { onStart: l, onMove: E } = this.handlers;
+      a || (l && l(this.lastMoveEvent, i), this.startEvent = this.lastMoveEvent), E && E(this.lastMoveEvent, i);
+    }, this.handlePointerMove = (i, a) => {
+      this.lastMoveEvent = i, this.lastMoveEventInfo = v(a, this.transformPagePoint), U.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (i, a) => {
+      this.end();
+      const { onEnd: c, onSessionEnd: f, resumeAnimation: m } = this.handlers;
+      if (this.dragSnapToOrigin && m && m(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const l = p(i.type === "pointercancel" ? this.lastMoveEventInfo : v(a, this.transformPagePoint), this.history);
+      this.startEvent && c && c(i, l), f && f(i, l);
+    }, !D(n))
+      return;
+    this.dragSnapToOrigin = h, this.handlers = o, this.transformPagePoint = e, this.contextWindow = r || window;
+    const s = T(n), u = v(s, this.transformPagePoint), { point: g } = u, { timestamp: I } = x;
+    this.history = [{ ...g, timestamp: I }];
+    const { onSessionStart: P } = o;
+    P && P(n, p(u, this.history)), this.removeListeners = L(d(this.contextWindow, "pointermove", this.handlePointerMove), d(this.contextWindow, "pointerup", this.handlePointerUp), d(this.contextWindow, "pointercancel", this.handlePointerUp));
+  }
+  updateHandlers(n) {
+    this.handlers = n;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), O(this.updatePoint);
+  }
+}
+function v(t, n) {
+  return n ? { point: n(t.point) } : t;
+}
+function y(t, n) {
+  return { x: t.x - n.x, y: t.y - n.y };
+}
+function p({ point: t }, n) {
+  return {
+    point: t,
+    delta: y(t, M(n)),
+    offset: y(t, V(n)),
+    velocity: b(n, 0.1)
+  };
+}
+function V(t) {
+  return t[0];
+}
+function M(t) {
+  return t[t.length - 1];
+}
+function b(t, n) {
+  if (t.length < 2)
+    return { x: 0, y: 0 };
+  let o = t.length - 1, e = null;
+  const r = M(t);
+  for (; o >= 0 && (e = t[o], !(r.timestamp - e.timestamp > w(n))); )
+    o--;
+  if (!e)
+    return { x: 0, y: 0 };
+  const h = S(r.timestamp - e.timestamp);
+  if (h === 0)
+    return { x: 0, y: 0 };
+  const s = {
+    x: (r.x - e.x) / h,
+    y: (r.y - e.y) / h
+  };
+  return s.x === 1 / 0 && (s.x = 0), s.y === 1 / 0 && (s.y = 0), s;
+}
 export {
-  i as r
+  B as PanSession
 };

package/dist/snorre.es794.js

@@ -1,7 +1,15 @@
-import e from "react";
-var t = /* @__PURE__ */ e.createContext(null);
-process.env.NODE_ENV !== "production" && (t.displayName = "ReactRedux");
+const e = {
+  /**
+   * Global flag as to whether the tree has animated since the last time
+   * we resized the window
+   */
+  hasAnimatedSinceResize: !0,
+  /**
+   * We set this to true once, on the first update. Any nodes added to the tree beyond that
+   * update will be given a `data-projection-id` attribute.
+   */
+  hasEverUpdated: !1
+};
 export {
-  t as ReactReduxContext,
-  t as default
+  e as globalProjectionState
 };

package/dist/snorre.es795.js

@@ -1,42 +1,21 @@
-import { statsBuffer as d } from "./snorre.es916.js";
-function C(m, u) {
-  let t = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), r = !1, n = !1;
-  const a = /* @__PURE__ */ new WeakSet();
-  let l = {
-    delta: 0,
-    timestamp: 0,
-    isProcessing: !1
-  }, f = 0;
-  function p(e) {
-    a.has(e) && (o.schedule(e), m()), f++, e(l);
-  }
-  const o = {
-    /**
-     * Schedule a process to run on the next frame.
-     */
-    schedule: (e, h = !1, c = !1) => {
-      const i = c && r ? t : s;
-      return h && a.add(e), i.has(e) || i.add(e), e;
-    },
-    /**
-     * Cancel the provided callback from running on the next frame.
-     */
-    cancel: (e) => {
-      s.delete(e), a.delete(e);
-    },
-    /**
-     * Execute all schedule callbacks.
-     */
-    process: (e) => {
-      if (l = e, r) {
-        n = !0;
-        return;
-      }
-      r = !0, [t, s] = [s, t], t.forEach(p), u && d.value && d.value.frameloop[u].push(f), f = 0, t.clear(), r = !1, n && (n = !1, o.process(e));
-    }
-  };
-  return o;
+import { px as c } from "./snorre.es680.js";
+function e(r, n) {
+  return n.max === n.min ? 0 : r / (n.max - n.min) * 100;
 }
+const f = {
+  correct: (r, n) => {
+    if (!n.target)
+      return r;
+    if (typeof r == "string")
+      if (c.test(r))
+        r = parseFloat(r);
+      else
+        return r;
+    const o = e(r, n.target.x), t = e(r, n.target.y);
+    return `${o}% ${t}%`;
+  }
+};
 export {
-  C as createRenderStep
+  f as correctBorderRadius,
+  e as pixelsToPercent
 };

package/dist/snorre.es796.js

@@ -1,128 +1,16 @@
-import { animateVisualElement as j } from "./snorre.es631.js";
-import { isAnimationControls as q } from "./snorre.es723.js";
-import { isKeyframesTarget as D } from "./snorre.es744.js";
-import { shallowCompare as k } from "./snorre.es934.js";
-import { getVariantContext as G } from "./snorre.es935.js";
-import { isVariantLabel as J } from "./snorre.es773.js";
-import { resolveVariant as L } from "./snorre.es632.js";
-import { variantPriorityOrder as B } from "./snorre.es774.js";
-const N = [...B].reverse(), Q = B.length;
-function U(e) {
-  return (f) => Promise.all(f.map(({ animation: c, options: v }) => j(e, c, v)));
-}
-function oe(e) {
-  let f = U(e), c = _(), v = !0;
-  const F = (s) => (t, p) => {
-    var l;
-    const r = L(e, p, s === "exit" ? (l = e.presenceContext) === null || l === void 0 ? void 0 : l.custom : void 0);
-    if (r) {
-      const { transition: u, transitionEnd: y, ...g } = r;
-      t = { ...t, ...g, ...y };
-    }
-    return t;
-  };
-  function H(s) {
-    f = s(e);
+import { mixNumber as i } from "./snorre.es711.js";
+import { complex as f } from "./snorre.es665.js";
+const y = {
+  correct: (e, { treeScale: c, projectionDelta: t }) => {
+    const a = e, o = f.parse(e);
+    if (o.length > 5)
+      return a;
+    const p = f.createTransformer(e), r = typeof o[0] != "number" ? 1 : 0, n = t.x.scale * c.x, m = t.y.scale * c.y;
+    o[0 + r] /= n, o[1 + r] /= m;
+    const s = i(n, m, 0.5);
+    return typeof o[2 + r] == "number" && (o[2 + r] /= s), typeof o[3 + r] == "number" && (o[3 + r] /= s), p(o);
   }
-  function K(s) {
-    const { props: t } = e, p = G(e.parent) || {}, l = [], r = /* @__PURE__ */ new Set();
-    let u = {}, y = 1 / 0;
-    for (let d = 0; d < Q; d++) {
-      const i = N[d], n = c[i], o = t[i] !== void 0 ? t[i] : p[i], w = J(o), P = i === s ? n.isActive : null;
-      P === !1 && (y = d);
-      let V = o === p[i] && o !== t[i] && w;
-      if (V && v && e.manuallyAnimateOnMount && (V = !1), n.protectedKeys = { ...u }, // If it isn't active and hasn't *just* been set as inactive
-      !n.isActive && P === null || // If we didn't and don't have any defined prop for this animation type
-      !o && !n.prevProp || // Or if the prop doesn't define an animation
-      q(o) || typeof o == "boolean")
-        continue;
-      const b = W(n.prevProp, o);
-      let C = b || // If we're making this variant active, we want to always make it active
-      i === s && n.isActive && !V && w || // If we removed a higher-priority variant (i is in reverse order)
-      d > y && w, I = !1;
-      const R = Array.isArray(o) ? o : [o];
-      let h = R.reduce(F(i), {});
-      P === !1 && (h = {});
-      const { prevResolvedValues: x = {} } = n, z = {
-        ...x,
-        ...h
-      }, O = (a) => {
-        C = !0, r.has(a) && (I = !0, r.delete(a)), n.needsAnimating[a] = !0;
-        const m = e.getValue(a);
-        m && (m.liveStyle = !1);
-      };
-      for (const a in z) {
-        const m = h[a], S = x[a];
-        if (u.hasOwnProperty(a))
-          continue;
-        let T = !1;
-        D(m) && D(S) ? T = !k(m, S) : T = m !== S, T ? m != null ? O(a) : r.add(a) : m !== void 0 && r.has(a) ? O(a) : n.protectedKeys[a] = !0;
-      }
-      n.prevProp = o, n.prevResolvedValues = h, n.isActive && (u = { ...u, ...h }), v && e.blockInitialAnimation && (C = !1), C && (!(V && b) || I) && l.push(...R.map((a) => ({
-        animation: a,
-        options: { type: i }
-      })));
-    }
-    if (r.size) {
-      const d = {};
-      if (typeof t.initial != "boolean") {
-        const i = L(e, Array.isArray(t.initial) ? t.initial[0] : t.initial);
-        i && i.transition && (d.transition = i.transition);
-      }
-      r.forEach((i) => {
-        const n = e.getBaseTarget(i), o = e.getValue(i);
-        o && (o.liveStyle = !0), d[i] = n ?? null;
-      }), l.push({ animation: d });
-    }
-    let g = !!l.length;
-    return v && (t.initial === !1 || t.initial === t.animate) && !e.manuallyAnimateOnMount && (g = !1), v = !1, g ? f(l) : Promise.resolve();
-  }
-  function M(s, t) {
-    var p;
-    if (c[s].isActive === t)
-      return Promise.resolve();
-    (p = e.variantChildren) === null || p === void 0 || p.forEach((r) => {
-      var u;
-      return (u = r.animationState) === null || u === void 0 ? void 0 : u.setActive(s, t);
-    }), c[s].isActive = t;
-    const l = K(s);
-    for (const r in c)
-      c[r].protectedKeys = {};
-    return l;
-  }
-  return {
-    animateChanges: K,
-    setActive: M,
-    setAnimateFunction: H,
-    getState: () => c,
-    reset: () => {
-      c = _(), v = !0;
-    }
-  };
-}
-function W(e, f) {
-  return typeof f == "string" ? f !== e : Array.isArray(f) ? !k(f, e) : !1;
-}
-function A(e = !1) {
-  return {
-    isActive: e,
-    protectedKeys: {},
-    needsAnimating: {},
-    prevResolvedValues: {}
-  };
-}
-function _() {
-  return {
-    animate: A(!0),
-    whileInView: A(),
-    whileHover: A(),
-    whileTap: A(),
-    whileDrag: A(),
-    whileFocus: A(),
-    exit: A()
-  };
-}
+};
 export {
-  W as checkVariantsDidChange,
-  oe as createAnimationState
+  y as correctBoxShadow
 };