@bbl-digital/snorre 4.2.93 → 4.2.95

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/features/animations.js

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

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/features/drag.js

@@ -0,0 +1,17 @@
+import { DragGesture as r } from "../../gestures/drag/index.js";
+import { PanGesture as o } from "../../gestures/pan/index.js";
+import { MeasureLayout as e } from "./layout/MeasureLayout.js";
+import { HTMLProjectionNode as t } from "../../projection/node/HTMLProjectionNode.js";
+const u = {
+  pan: {
+    Feature: o
+  },
+  drag: {
+    Feature: r,
+    ProjectionNode: t,
+    MeasureLayout: e
+  }
+};
+export {
+  u as drag
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/features/gestures.js

@@ -0,0 +1,21 @@
+import { HoverGesture as e } from "../../gestures/hover.js";
+import { FocusGesture as r } from "../../gestures/focus.js";
+import { PressGesture as t } from "../../gestures/press.js";
+import { InViewFeature as o } from "./viewport/index.js";
+const a = {
+  inView: {
+    Feature: o
+  },
+  tap: {
+    Feature: t
+  },
+  focus: {
+    Feature: r
+  },
+  hover: {
+    Feature: e
+  }
+};
+export {
+  a as gestureAnimations
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/features/layout/MeasureLayout.js

@@ -0,0 +1,74 @@
+import { j as m } from "../../../../../../../../../react/jsx-runtime.js";
+import { useContext as u, Component as d } from "react";
+import { usePresence as c } from "../../../components/AnimatePresence/use-presence.js";
+import { LayoutGroupContext as f } from "../../../context/LayoutGroupContext.js";
+import { SwitchLayoutGroupContext as l } from "../../../context/SwitchLayoutGroupContext.js";
+import { microtask as h } from "../../../frameloop/microtask.js";
+import { globalProjectionState as R } from "../../../projection/node/state.js";
+import { correctBorderRadius as n } from "../../../projection/styles/scale-border-radius.js";
+import { correctBoxShadow as g } from "../../../projection/styles/scale-box-shadow.js";
+import { addScaleCorrector as y } from "../../../projection/styles/scale-correction.js";
+import { frame as v } from "../../../frameloop/frame.js";
+class T extends d {
+  /**
+   * This only mounts projection nodes for components that
+   * need measuring, we might want to do it for all components
+   * in order to incorporate transforms
+   */
+  componentDidMount() {
+    const { visualElement: o, layoutGroup: t, switchLayoutGroup: r, layoutId: s } = this.props, { projection: e } = o;
+    y(x), e && (t.group && t.group.add(e), r && r.register && s && r.register(e), e.root.didUpdate(), e.addEventListener("animationComplete", () => {
+      this.safeToRemove();
+    }), e.setOptions({
+      ...e.options,
+      onExitComplete: () => this.safeToRemove()
+    })), R.hasEverUpdated = !0;
+  }
+  getSnapshotBeforeUpdate(o) {
+    const { layoutDependency: t, visualElement: r, drag: s, isPresent: e } = this.props, i = r.projection;
+    return i && (i.isPresent = e, s || o.layoutDependency !== t || t === void 0 || o.isPresent !== e ? i.willUpdate() : this.safeToRemove(), o.isPresent !== e && (e ? i.promote() : i.relegate() || v.postRender(() => {
+      const p = i.getStack();
+      (!p || !p.members.length) && this.safeToRemove();
+    }))), null;
+  }
+  componentDidUpdate() {
+    const { projection: o } = this.props.visualElement;
+    o && (o.root.didUpdate(), h.postRender(() => {
+      !o.currentAnimation && o.isLead() && this.safeToRemove();
+    }));
+  }
+  componentWillUnmount() {
+    const { visualElement: o, layoutGroup: t, switchLayoutGroup: r } = this.props, { projection: s } = o;
+    s && (s.scheduleCheckAfterUnmount(), t && t.group && t.group.remove(s), r && r.deregister && r.deregister(s));
+  }
+  safeToRemove() {
+    const { safeToRemove: o } = this.props;
+    o && o();
+  }
+  render() {
+    return null;
+  }
+}
+function k(a) {
+  const [o, t] = c(), r = u(f);
+  return m.jsx(T, { ...a, layoutGroup: r, switchLayoutGroup: u(l), isPresent: o, safeToRemove: t });
+}
+const x = {
+  borderRadius: {
+    ...n,
+    applyTo: [
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius"
+    ]
+  },
+  borderTopLeftRadius: n,
+  borderTopRightRadius: n,
+  borderBottomLeftRadius: n,
+  borderBottomRightRadius: n,
+  boxShadow: g
+};
+export {
+  k as MeasureLayout
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/features/layout.js

@@ -0,0 +1,11 @@
+import { HTMLProjectionNode as o } from "../../projection/node/HTMLProjectionNode.js";
+import { MeasureLayout as t } from "./layout/MeasureLayout.js";
+const a = {
+  layout: {
+    ProjectionNode: o,
+    MeasureLayout: t
+  }
+};
+export {
+  a as layout
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/features/load-features.js

@@ -0,0 +1,11 @@
+import { featureDefinitions as n } from "./definitions.js";
+function e(i) {
+  for (const o in i)
+    n[o] = {
+      ...n[o],
+      ...i[o]
+    };
+}
+export {
+  e as loadFeatures
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/features/viewport/index.js

@@ -0,0 +1,44 @@
+import { Feature as m } from "../Feature.js";
+import { observeIntersection as f } from "./observers.js";
+const w = {
+  some: 0,
+  all: 1
+};
+class v extends m {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: n = {} } = this.node.getProps(), { root: t, margin: r, amount: s = "some", once: h } = n, u = {
+      root: t ? t.current : void 0,
+      rootMargin: r,
+      threshold: typeof s == "number" ? s : w[s]
+    }, c = (i) => {
+      const { isIntersecting: e } = i;
+      if (this.isInView === e || (this.isInView = e, h && !e && this.hasEnteredView))
+        return;
+      e && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", e);
+      const { onViewportEnter: p, onViewportLeave: d } = this.node.getProps(), a = e ? p : d;
+      a && a(i);
+    };
+    return f(this.node.current, u, c);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: n, prevProps: t } = this.node;
+    ["amount", "margin", "root"].some(l(n, t)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function l({ viewport: o = {} }, { viewport: n = {} } = {}) {
+  return (t) => o[t] !== n[t];
+}
+export {
+  v as InViewFeature
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/index.js

@@ -0,0 +1,59 @@
+import { j as M } from "../../../../../../../react/jsx-runtime.js";
+import { warning as E, invariant as g } from "../../../../motion-utils/dist/es/errors.js";
+import { forwardRef as j, useContext as d } from "react";
+import { LayoutGroupContext as L } from "../context/LayoutGroupContext.js";
+import { LazyContext as N } from "../context/LazyContext.js";
+import { MotionConfigContext as P } from "../context/MotionConfigContext.js";
+import { MotionContext as b } from "../context/MotionContext/index.js";
+import { useCreateMotionContext as w } from "../context/MotionContext/create.js";
+import { isBrowser as C } from "../utils/is-browser.js";
+import { featureDefinitions as S } from "./features/definitions.js";
+import { loadFeatures as h } from "./features/load-features.js";
+import { motionComponentSymbol as R } from "./utils/symbol.js";
+import { useMotionRef as _ } from "./utils/use-motion-ref.js";
+import { useVisualElement as k } from "./utils/use-visual-element.js";
+function U({ preloadedFeatures: o, createVisualElement: t, useRender: e, useVisualState: n, Component: i }) {
+  var u, m;
+  o && h(o);
+  function v(a, x) {
+    let c;
+    const s = {
+      ...d(P),
+      ...a,
+      layoutId: z(a)
+    }, { isStatic: l } = s, r = w(a), f = n(a, l);
+    if (!l && C) {
+      D(s, o);
+      const p = G(s);
+      c = p.MeasureLayout, r.visualElement = k(i, f, s, t, p.ProjectionNode);
+    }
+    return M.jsxs(b.Provider, { value: r, children: [c && r.visualElement ? M.jsx(c, { visualElement: r.visualElement, ...s }) : null, e(i, a, _(f, r.visualElement, x), f, l, r.visualElement)] });
+  }
+  v.displayName = `motion.${typeof i == "string" ? i : `create(${(m = (u = i.displayName) !== null && u !== void 0 ? u : i.name) !== null && m !== void 0 ? m : ""})`}`;
+  const y = j(v);
+  return y[R] = i, y;
+}
+function z({ layoutId: o }) {
+  const t = d(L).id;
+  return t && o !== void 0 ? t + "-" + o : o;
+}
+function D(o, t) {
+  const e = d(N).strict;
+  if (process.env.NODE_ENV !== "production" && t && e) {
+    const n = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    o.ignoreStrict ? E(!1, n) : g(!1, n);
+  }
+}
+function G(o) {
+  const { drag: t, layout: e } = S;
+  if (!t && !e)
+    return {};
+  const n = { ...t, ...e };
+  return {
+    MeasureLayout: t != null && t.isEnabled(o) || e != null && e.isEnabled(o) ? n.MeasureLayout : void 0,
+    ProjectionNode: n.ProjectionNode
+  };
+}
+export {
+  U as createRendererMotionComponent
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/utils/is-forced-motion-value.js

@@ -0,0 +1,8 @@
+import { scaleCorrectors as i } from "../../projection/styles/scale-correction.js";
+import { transformProps as n } from "../../render/html/utils/keys-transform.js";
+function c(r, { layout: o, layoutId: t }) {
+  return n.has(r) || r.startsWith("origin") || (o || t !== void 0) && (!!i[r] || r === "opacity");
+}
+export {
+  c as isForcedMotionValue
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/utils/use-motion-ref.js

@@ -0,0 +1,18 @@
+import { useCallback as p } from "react";
+import { isRefObject as i } from "../../utils/is-ref-object.js";
+function b(r, u, f) {
+  return p(
+    (o) => {
+      o && r.onMount && r.onMount(o), u && (o ? u.mount(o) : u.unmount()), f && (typeof f == "function" ? f(o) : i(f) && (f.current = o));
+    },
+    /**
+     * Only pass a new ref callback to React if we've received a visual element
+     * factory. Otherwise we'll be mounting/remounting every time externalRef
+     * or other dependencies change.
+     */
+    [u]
+  );
+}
+export {
+  b as useMotionRef
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/utils/use-visual-element.js

@@ -0,0 +1,64 @@
+import { useContext as f, useRef as C, useInsertionEffect as j, useEffect as I } from "react";
+import { PresenceContext as h } from "../../context/PresenceContext.js";
+import { MotionContext as A } from "../../context/MotionContext/index.js";
+import { useIsomorphicLayoutEffect as S } from "../../utils/use-isomorphic-effect.js";
+import { LazyContext as b } from "../../context/LazyContext.js";
+import { MotionConfigContext as v } from "../../context/MotionConfigContext.js";
+import { optimizedAppearDataAttribute as L } from "../../animation/optimized-appear/data-id.js";
+import { microtask as k } from "../../frameloop/microtask.js";
+import { isRefObject as H } from "../../utils/is-ref-object.js";
+import { SwitchLayoutGroupContext as R } from "../../context/SwitchLayoutGroupContext.js";
+function J(o, u, e, i, c) {
+  var n, a;
+  const { visualElement: s } = f(A), l = f(b), r = f(h), g = f(v).reducedMotion, d = C(null);
+  i = i || l.renderer, !d.current && i && (d.current = i(o, {
+    visualState: u,
+    parent: s,
+    props: e,
+    presenceContext: r,
+    blockInitialAnimation: r ? r.initial === !1 : !1,
+    reducedMotionConfig: g
+  }));
+  const t = d.current, x = f(R);
+  t && !t.projection && c && (t.type === "html" || t.type === "svg") && z(d.current, e, c, x);
+  const y = C(!1);
+  j(() => {
+    t && y.current && t.update(e, r);
+  });
+  const m = e[L], p = C(!!m && !(!((n = window.MotionHandoffIsComplete) === null || n === void 0) && n.call(window, m)) && ((a = window.MotionHasOptimisedAnimation) === null || a === void 0 ? void 0 : a.call(window, m)));
+  return S(() => {
+    t && (y.current = !0, window.MotionIsMounted = !0, t.updateFeatures(), k.render(t.render), p.current && t.animationState && t.animationState.animateChanges());
+  }), I(() => {
+    t && (!p.current && t.animationState && t.animationState.animateChanges(), p.current && (queueMicrotask(() => {
+      var w;
+      (w = window.MotionHandoffMarkAsComplete) === null || w === void 0 || w.call(window, m);
+    }), p.current = !1));
+  }), t;
+}
+function z(o, u, e, i) {
+  const { layoutId: c, layout: n, drag: a, dragConstraints: s, layoutScroll: l, layoutRoot: r } = u;
+  o.projection = new e(o.latestValues, u["data-framer-portal-id"] ? void 0 : M(o.parent)), o.projection.setOptions({
+    layoutId: c,
+    layout: n,
+    alwaysMeasureLayout: !!a || s && H(s),
+    visualElement: o,
+    /**
+     * TODO: Update options in an effect. This could be tricky as it'll be too late
+     * to update by the time layout animations run.
+     * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
+     * ensuring it gets called if there's no potential layout animations.
+     *
+     */
+    animationType: typeof n == "string" ? n : "both",
+    initialPromotionConfig: i,
+    layoutScroll: l,
+    layoutRoot: r
+  });
+}
+function M(o) {
+  if (o)
+    return o.options.allowProjection !== !1 ? o.projection : M(o.parent);
+}
+export {
+  J as useVisualElement
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/motion/utils/use-visual-state.js

@@ -0,0 +1,53 @@
+import { useContext as C } from "react";
+import { isAnimationControls as x } from "../../animation/utils/is-animation-controls.js";
+import { MotionContext as S } from "../../context/MotionContext/index.js";
+import { PresenceContext as h } from "../../context/PresenceContext.js";
+import { isControllingVariants as M, isVariantNode as N } from "../../render/utils/is-controlling-variants.js";
+import { resolveVariantFromProps as P } from "../../render/utils/resolve-variants.js";
+import { useConstant as T } from "../../utils/use-constant.js";
+import { resolveMotionValue as $ } from "../../value/utils/resolve-motion-value.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
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/projection/animation/mix-values.js

@@ -0,0 +1,32 @@
+import { noop as R } from "../../../../../motion-utils/dist/es/noop.js";
+import { progress as h } from "../../../../../motion-utils/dist/es/progress.js";
+import { circOut as B } from "../../easing/circ.js";
+import { mixNumber as f } from "../../utils/mix/number.js";
+import { px as L, percent as u } from "../../value/types/numbers/units.js";
+const a = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"], M = a.length, p = (t) => typeof t == "string" ? parseFloat(t) : t, d = (t) => typeof t == "number" || L.test(t);
+function V(t, i, o, n, b, x) {
+  b ? (t.opacity = f(
+    0,
+    // TODO Reinstate this if only child
+    o.opacity !== void 0 ? o.opacity : 1,
+    C(n)
+  ), t.opacityExit = f(i.opacity !== void 0 ? i.opacity : 1, 0, O(n))) : x && (t.opacity = f(i.opacity !== void 0 ? i.opacity : 1, o.opacity !== void 0 ? o.opacity : 1, n));
+  for (let s = 0; s < M; s++) {
+    const c = `border${a[s]}Radius`;
+    let r = m(i, c), e = m(o, c);
+    if (r === void 0 && e === void 0)
+      continue;
+    r || (r = 0), e || (e = 0), r === 0 || e === 0 || d(r) === d(e) ? (t[c] = Math.max(f(p(r), p(e), n), 0), (u.test(e) || u.test(r)) && (t[c] += "%")) : t[c] = e;
+  }
+  (i.rotate || o.rotate) && (t.rotate = f(i.rotate || 0, o.rotate || 0, n));
+}
+function m(t, i) {
+  return t[i] !== void 0 ? t[i] : t.borderRadius;
+}
+const C = /* @__PURE__ */ y(0, 0.5, B), O = /* @__PURE__ */ y(0.5, 0.95, R);
+function y(t, i, o) {
+  return (n) => n < t ? 0 : n > i ? 1 : o(h(t, i, n));
+}
+export {
+  V as mixValues
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/projection/geometry/delta-apply.js

@@ -0,0 +1,52 @@
+import { mixNumber as x } from "../../utils/mix/number.js";
+import { hasTransform as E } from "../utils/has-transform.js";
+function y(t, n, o) {
+  const i = t - o, s = n * i;
+  return o + s;
+}
+function e(t, n, o, i, s) {
+  return s !== void 0 && (t = y(t, s, i)), y(t, o, i) + n;
+}
+function p(t, n = 0, o = 1, i, s) {
+  t.min = e(t.min, n, o, i, s), t.max = e(t.max, n, o, i, s);
+}
+function _(t, { x: n, y: o }) {
+  p(t.x, n.translate, n.scale, n.originPoint), p(t.y, o.translate, o.scale, o.originPoint);
+}
+const m = 0.999999999999, a = 1.0000000000001;
+function D(t, n, o, i = !1) {
+  const s = o.length;
+  if (!s)
+    return;
+  n.x = n.y = 1;
+  let l, f;
+  for (let c = 0; c < s; c++) {
+    l = o[c], f = l.projectionDelta;
+    const { visualElement: u } = l.options;
+    u && u.props.style && u.props.style.display === "contents" || (i && l.options.layoutScroll && l.scroll && l !== l.root && A(t, {
+      x: -l.scroll.offset.x,
+      y: -l.scroll.offset.y
+    }), f && (n.x *= f.x.scale, n.y *= f.y.scale, _(t, f)), i && E(l.latestValues) && A(t, l.latestValues));
+  }
+  n.x < a && n.x > m && (n.x = 1), n.y < a && n.y > m && (n.y = 1);
+}
+function N(t, n) {
+  t.min = t.min + n, t.max = t.max + n;
+}
+function r(t, n, o, i, s = 0.5) {
+  const l = x(t.min, t.max, s);
+  p(t, n, o, l, i);
+}
+function A(t, n) {
+  r(t.x, n.x, n.scaleX, n.scale, n.originX), r(t.y, n.y, n.scaleY, n.scale, n.originY);
+}
+export {
+  p as applyAxisDelta,
+  _ as applyBoxDelta,
+  e as applyPointDelta,
+  D as applyTreeDeltas,
+  y as scalePoint,
+  r as transformAxis,
+  A as transformBox,
+  N as translateAxis
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/projection/geometry/delta-calc.js

@@ -0,0 +1,36 @@
+import { mixNumber as m } from "../../utils/mix/number.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/node_modules/motion/dist/es/framer-motion/dist/es/projection/geometry/delta-remove.js

@@ -0,0 +1,25 @@
+import { mixNumber as v } from "../../utils/mix/number.js";
+import { percent as p } from "../../value/types/numbers/units.js";
+import { scalePoint as r } from "./delta-apply.js";
+function c(e, m, f, n, d) {
+  return e -= m, e = r(e, 1 / f, n), d !== void 0 && (e = r(e, 1 / d, n)), e;
+}
+function D(e, m = 0, f = 1, n = 0.5, d, u = e, y = e) {
+  if (p.test(m) && (m = parseFloat(m), m = v(y.min, y.max, m / 100) - y.min), typeof m != "number")
+    return;
+  let i = v(u.min, u.max, n);
+  e === u && (i -= m), e.min = c(e.min, m, f, i, d), e.max = c(e.max, m, f, i, d);
+}
+function P(e, m, [f, n, d], u, y) {
+  D(e, m[f], m[n], m[d], m.scale, u, y);
+}
+const K = ["x", "scaleX", "originX"], T = ["y", "scaleY", "originY"];
+function N(e, m, f, n) {
+  P(e.x, m, K, f ? f.x : void 0, n ? n.x : void 0), P(e.y, m, T, f ? f.y : void 0, n ? n.y : void 0);
+}
+export {
+  D as removeAxisDelta,
+  P as removeAxisTransforms,
+  N as removeBoxTransforms,
+  c as removePointDelta
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/projection/geometry/utils.js

@@ -0,0 +1,34 @@
+import { calcLength as r } from "./delta-calc.js";
+function u(n) {
+  return n.translate === 0 && n.scale === 1;
+}
+function e(n) {
+  return u(n.x) && u(n.y);
+}
+function i(n, t) {
+  return n.min === t.min && n.max === t.max;
+}
+function s(n, t) {
+  return i(n.x, t.x) && i(n.y, t.y);
+}
+function o(n, t) {
+  return Math.round(n.min) === Math.round(t.min) && Math.round(n.max) === Math.round(t.max);
+}
+function x(n, t) {
+  return o(n.x, t.x) && o(n.y, t.y);
+}
+function c(n) {
+  return r(n.x) / r(n.y);
+}
+function l(n, t) {
+  return n.translate === t.translate && n.scale === t.scale && n.originPoint === t.originPoint;
+}
+export {
+  c as aspectRatio,
+  l as axisDeltaEquals,
+  i as axisEquals,
+  o as axisEqualsRounded,
+  s as boxEquals,
+  x as boxEqualsRounded,
+  e as isDeltaZero
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/projection/node/DocumentProjectionNode.js

@@ -0,0 +1,13 @@
+import { createProjectionNode as t } from "./create-projection-node.js";
+import { addDomEvent as c } from "../../events/add-dom-event.js";
+const l = t({
+  attachResizeListener: (o, e) => c(o, "resize", e),
+  measureScroll: () => ({
+    x: document.documentElement.scrollLeft || document.body.scrollLeft,
+    y: document.documentElement.scrollTop || document.body.scrollTop
+  }),
+  checkIsScrollRoot: () => !0
+});
+export {
+  l as DocumentProjectionNode
+};

package/dist/node_modules/motion/dist/es/framer-motion/dist/es/projection/node/HTMLProjectionNode.js

@@ -0,0 +1,25 @@
+import { createProjectionNode as t } from "./create-projection-node.js";
+import { DocumentProjectionNode as n } from "./DocumentProjectionNode.js";
+const e = {
+  current: void 0
+}, i = t({
+  measureScroll: (o) => ({
+    x: o.scrollLeft,
+    y: o.scrollTop
+  }),
+  defaultParent: () => {
+    if (!e.current) {
+      const o = new n({});
+      o.mount(window), o.setOptions({ layoutScroll: !0 }), e.current = o;
+    }
+    return e.current;
+  },
+  resetTransform: (o, r) => {
+    o.style.transform = r !== void 0 ? r : "none";
+  },
+  checkIsScrollRoot: (o) => window.getComputedStyle(o).position === "fixed"
+});
+export {
+  i as HTMLProjectionNode,
+  e as rootProjectionNode
+};