motion-v 0.2.6 → 0.3.0

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/batcher.mjs

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

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/frame.mjs

@@ -0,0 +1,9 @@
+import { noop as e } from "../utils/noop.mjs";
+import { createRenderBatcher as r } from "./batcher.mjs";
+const { schedule: m, cancel: n, state: o, steps: c } = r(typeof requestAnimationFrame < "u" ? requestAnimationFrame : e, !0);
+export {
+  n as cancelFrame,
+  m as frame,
+  o as frameData,
+  c as frameSteps
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/index-legacy.mjs

@@ -0,0 +1,7 @@
+import { stepsOrder as n } from "./batcher.mjs";
+import { frame as o, cancelFrame as t } from "./frame.mjs";
+const p = o, a = n.reduce((r, e) => (r[e] = (c) => t(c), r), {});
+export {
+  a as cancelSync,
+  p as sync
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/render-step.mjs

@@ -0,0 +1,41 @@
+function p(d) {
+  let s = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), r = !1, n = !1;
+  const a = /* @__PURE__ */ new WeakSet();
+  let i = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  };
+  function u(e) {
+    a.has(e) && (f.schedule(e), d()), e(i);
+  }
+  const f = {
+    /**
+     * Schedule a process to run on the next frame.
+     */
+    schedule: (e, l = !1, h = !1) => {
+      const o = h && r ? s : t;
+      return l && a.add(e), o.has(e) || o.add(e), e;
+    },
+    /**
+     * Cancel the provided callback from running on the next frame.
+     */
+    cancel: (e) => {
+      t.delete(e), a.delete(e);
+    },
+    /**
+     * Execute all schedule callbacks.
+     */
+    process: (e) => {
+      if (i = e, r) {
+        n = !0;
+        return;
+      }
+      r = !0, [s, t] = [t, s], t.clear(), s.forEach(u), r = !1, n && (n = !1, f.process(e));
+    }
+  };
+  return f;
+}
+export {
+  p as createRenderStep
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/sync-time.mjs

@@ -0,0 +1,15 @@
+import { MotionGlobalConfig as i } from "../utils/GlobalConfig.mjs";
+import { frameData as n } from "./frame.mjs";
+let e;
+function t() {
+  e = void 0;
+}
+const r = {
+  now: () => (e === void 0 && r.set(n.isProcessing || i.useManualTiming ? n.timestamp : performance.now()), e),
+  set: (o) => {
+    e = o, queueMicrotask(t);
+  }
+};
+export {
+  r as time
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/motion/features/definitions.mjs

@@ -0,0 +1,27 @@
+const n = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+  layout: ["layout", "layoutId"]
+}, t = {};
+for (const e in n)
+  t[e] = {
+    isEnabled: (o) => n[e].some((a) => !!o[a])
+  };
+export {
+  t as featureDefinitions
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs

@@ -0,0 +1,8 @@
+import { scaleCorrectors as i } from "../../projection/styles/scale-correction.mjs";
+import { transformProps as n } from "../../render/html/utils/transform.mjs";
+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/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs

@@ -0,0 +1,21 @@
+function n({ top: t, left: o, right: x, bottom: e }) {
+  return {
+    x: { min: o, max: x },
+    y: { min: t, max: e }
+  };
+}
+function r(t, o) {
+  if (!o)
+    return t;
+  const x = o({ x: t.left, y: t.top }), e = o({ x: t.right, y: t.bottom });
+  return {
+    top: x.y,
+    left: x.x,
+    bottom: e.y,
+    right: e.x
+  };
+}
+export {
+  n as convertBoundingBoxToBox,
+  r as transformBoxPoints
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/projection/geometry/models.mjs

@@ -0,0 +1,8 @@
+const e = () => ({ min: 0, max: 0 }), t = () => ({
+  x: e(),
+  y: e()
+});
+export {
+  e as createAxis,
+  t as createBox
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs

@@ -0,0 +1,4 @@
+const o = {};
+export {
+  o as scaleCorrectors
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/projection/utils/measure.mjs

@@ -0,0 +1,7 @@
+import { convertBoundingBoxToBox as t, transformBoxPoints as r } from "../geometry/conversion.mjs";
+function i(o, n) {
+  return t(r(o.getBoundingClientRect(), n));
+}
+export {
+  i as measureViewportBox
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/VisualElement.mjs

@@ -0,0 +1,226 @@
+import { initPrefersReducedMotion as g } from "../utils/reduced-motion/index.mjs";
+import { hasReducedMotionListener as M, prefersReducedMotion as S } from "../utils/reduced-motion/state.mjs";
+import { SubscriptionManager as C } from "../utils/subscription-manager.mjs";
+import { motionValue as b } from "../value/index.mjs";
+import { isMotionValue as h } from "../value/utils/is-motion-value.mjs";
+import { transformProps as P } from "./html/utils/transform.mjs";
+import { isControllingVariants as T, isVariantNode as w } from "./utils/is-controlling-variants.mjs";
+import { updateMotionValuesFromProps as F } from "./utils/motion-values.mjs";
+import { resolveVariantFromProps as R } from "./utils/resolve-variants.mjs";
+import { warnOnce as N } from "../utils/warn-once.mjs";
+import { featureDefinitions as d } from "../motion/features/definitions.mjs";
+import { visualElementStore as c } from "./store.mjs";
+import { KeyframeResolver as E } from "./utils/KeyframesResolver.mjs";
+import { isNumericalString as x } from "../utils/is-numerical-string.mjs";
+import { isZeroValueString as A } from "../utils/is-zero-value-string.mjs";
+import { findValueType as B } from "./dom/value-types/find.mjs";
+import { complex as j } from "../value/types/complex/index.mjs";
+import { getAnimatableNone as y } from "./dom/value-types/animatable-none.mjs";
+import { createBox as I } from "../projection/geometry/models.mjs";
+import { time as U } from "../frameloop/sync-time.mjs";
+import { frame as f, cancelFrame as m } from "../frameloop/frame.mjs";
+const V = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+class ot {
+  /**
+   * This method takes React props and returns found MotionValues. For example, HTML
+   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+   *
+   * This isn't an abstract method as it needs calling in the constructor, but it is
+   * intended to be one.
+   */
+  scrapeMotionValuesFromProps(t, e, s) {
+    return {};
+  }
+  constructor({ parent: t, props: e, presenceContext: s, reducedMotionConfig: i, blockInitialAnimation: r, visualState: n }, u = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = E, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+    }, this.renderScheduledAt = 0, this.scheduleRender = () => {
+      const o = U.now();
+      this.renderScheduledAt < o && (this.renderScheduledAt = o, f.render(this.render, !1, !0));
+    };
+    const { latestValues: a, renderState: v } = n;
+    this.latestValues = a, this.baseTarget = { ...a }, this.initialValues = e.initial ? { ...a } : {}, this.renderState = v, this.parent = t, this.props = e, this.presenceContext = s, this.depth = t ? t.depth + 1 : 0, this.reducedMotionConfig = i, this.options = u, this.blockInitialAnimation = !!r, this.isControllingVariants = T(e), this.isVariantNode = w(e), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(t && t.current);
+    const { willChange: D, ...l } = this.scrapeMotionValuesFromProps(e, {}, this);
+    for (const o in l) {
+      const p = l[o];
+      a[o] !== void 0 && h(p) && p.set(a[o], !1);
+    }
+  }
+  mount(t) {
+    this.current = t, c.set(t, this), this.projection && !this.projection.instance && this.projection.mount(t), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((e, s) => this.bindToMotionValue(s, e)), M.current || g(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : S.current, process.env.NODE_ENV !== "production" && N(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected."), this.parent && this.parent.children.add(this), this.update(this.props, this.presenceContext);
+  }
+  unmount() {
+    c.delete(this.current), this.projection && this.projection.unmount(), m(this.notifyUpdate), m(this.render), this.valueSubscriptions.forEach((t) => t()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent && this.parent.children.delete(this);
+    for (const t in this.events)
+      this.events[t].clear();
+    for (const t in this.features) {
+      const e = this.features[t];
+      e && (e.unmount(), e.isMounted = !1);
+    }
+    this.current = null;
+  }
+  bindToMotionValue(t, e) {
+    this.valueSubscriptions.has(t) && this.valueSubscriptions.get(t)();
+    const s = P.has(t), i = e.on("change", (u) => {
+      this.latestValues[t] = u, this.props.onUpdate && f.preRender(this.notifyUpdate), s && this.projection && (this.projection.isTransformDirty = !0);
+    }), r = e.on("renderRequest", this.scheduleRender);
+    let n;
+    window.MotionCheckAppearSync && (n = window.MotionCheckAppearSync(this, t, e)), this.valueSubscriptions.set(t, () => {
+      i(), r(), n && n(), e.owner && e.stop();
+    });
+  }
+  sortNodePosition(t) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== t.type ? 0 : this.sortInstanceNodePosition(this.current, t.current);
+  }
+  updateFeatures() {
+    let t = "animation";
+    for (t in d) {
+      const e = d[t];
+      if (!e)
+        continue;
+      const { isEnabled: s, Feature: i } = e;
+      if (!this.features[t] && i && s(this.props) && (this.features[t] = new i(this)), this.features[t]) {
+        const r = this.features[t];
+        r.isMounted ? r.update() : (r.mount(), r.isMounted = !0);
+      }
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.props);
+  }
+  /**
+   * Measure the current viewport box with or without transforms.
+   * Only measures axis-aligned boxes, rotate and skew must be manually
+   * removed with a re-render to work.
+   */
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : I();
+  }
+  getStaticValue(t) {
+    return this.latestValues[t];
+  }
+  setStaticValue(t, e) {
+    this.latestValues[t] = e;
+  }
+  /**
+   * Update the provided props. Ensure any newly-added motion values are
+   * added to our map, old ones removed, and listeners updated.
+   */
+  update(t, e) {
+    (t.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = t, this.prevPresenceContext = this.presenceContext, this.presenceContext = e;
+    for (let s = 0; s < V.length; s++) {
+      const i = V[s];
+      this.propEventSubscriptions[i] && (this.propEventSubscriptions[i](), delete this.propEventSubscriptions[i]);
+      const r = "on" + i, n = t[r];
+      n && (this.propEventSubscriptions[i] = this.on(i, n));
+    }
+    this.prevMotionValues = F(this, this.scrapeMotionValuesFromProps(t, this.prevProps, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+   * Returns the variant definition with a given name.
+   */
+  getVariant(t) {
+    return this.props.variants ? this.props.variants[t] : void 0;
+  }
+  /**
+   * Returns the defined default transition on this component.
+   */
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  /**
+   * Add a child visual element to our set of children.
+   */
+  addVariantChild(t) {
+    const e = this.getClosestVariantNode();
+    if (e)
+      return e.variantChildren && e.variantChildren.add(t), () => e.variantChildren.delete(t);
+  }
+  /**
+   * Add a motion value and bind it to this visual element.
+   */
+  addValue(t, e) {
+    const s = this.values.get(t);
+    e !== s && (s && this.removeValue(t), this.bindToMotionValue(t, e), this.values.set(t, e), this.latestValues[t] = e.get());
+  }
+  /**
+   * Remove a motion value and unbind any active subscriptions.
+   */
+  removeValue(t) {
+    this.values.delete(t);
+    const e = this.valueSubscriptions.get(t);
+    e && (e(), this.valueSubscriptions.delete(t)), delete this.latestValues[t], this.removeValueFromRenderState(t, this.renderState);
+  }
+  /**
+   * Check whether we have a motion value for this key
+   */
+  hasValue(t) {
+    return this.values.has(t);
+  }
+  getValue(t, e) {
+    if (this.props.values && this.props.values[t])
+      return this.props.values[t];
+    let s = this.values.get(t);
+    return s === void 0 && e !== void 0 && (s = b(e === null ? void 0 : e, { owner: this }), this.addValue(t, s)), s;
+  }
+  /**
+   * If we're trying to animate to a previously unencountered value,
+   * we need to check for it in our state and as a last resort read it
+   * directly from the instance (which might have performance implications).
+   */
+  readValue(t, e) {
+    var s;
+    let i = this.latestValues[t] !== void 0 || !this.current ? this.latestValues[t] : (s = this.getBaseTargetFromProps(this.props, t)) !== null && s !== void 0 ? s : this.readValueFromInstance(this.current, t, this.options);
+    return i != null && (typeof i == "string" && (x(i) || A(i)) ? i = parseFloat(i) : !B(i) && j.test(e) && (i = y(t, e)), this.setBaseTarget(t, h(i) ? i.get() : i)), h(i) ? i.get() : i;
+  }
+  /**
+   * Set the base target to later animate back to. This is currently
+   * only hydrated on creation and when we first read a value.
+   */
+  setBaseTarget(t, e) {
+    this.baseTarget[t] = e;
+  }
+  /**
+   * Find the base target for a value thats been removed from all animation
+   * props.
+   */
+  getBaseTarget(t) {
+    var e;
+    const { initial: s } = this.props;
+    let i;
+    if (typeof s == "string" || typeof s == "object") {
+      const n = R(this.props, s, (e = this.presenceContext) === null || e === void 0 ? void 0 : e.custom);
+      n && (i = n[t]);
+    }
+    if (s && i !== void 0)
+      return i;
+    const r = this.getBaseTargetFromProps(this.props, t);
+    return r !== void 0 && !h(r) ? r : this.initialValues[t] !== void 0 && i === void 0 ? void 0 : this.baseTarget[t];
+  }
+  on(t, e) {
+    return this.events[t] || (this.events[t] = new C()), this.events[t].add(e);
+  }
+  notify(t, ...e) {
+    this.events[t] && this.events[t].notify(...e);
+  }
+}
+export {
+  ot as VisualElement
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs

@@ -0,0 +1,65 @@
+import { isNone as h } from "../../animation/utils/is-none.mjs";
+import { getVariableValue as y } from "./utils/css-variables-conversion.mjs";
+import { isCSSVariableToken as p } from "./utils/is-css-variable.mjs";
+import { positionalKeys as g, isNumOrPxType as l, positionalValues as u } from "./utils/unit-conversion.mjs";
+import { findDimensionValueType as d } from "./value-types/dimensions.mjs";
+import { KeyframeResolver as c } from "../utils/KeyframesResolver.mjs";
+import { makeNoneKeyframesAnimatable as K } from "../html/utils/make-none-animatable.mjs";
+class b extends c {
+  constructor(e, r, n, t, o) {
+    super(e, r, n, t, o, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, element: r, name: n } = this;
+    if (!r || !r.current)
+      return;
+    super.readKeyframes();
+    for (let s = 0; s < e.length; s++) {
+      let i = e[s];
+      if (typeof i == "string" && (i = i.trim(), p(i))) {
+        const m = y(i, r.current);
+        m !== void 0 && (e[s] = m), s === e.length - 1 && (this.finalKeyframe = i);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !g.has(n) || e.length !== 2)
+      return;
+    const [t, o] = e, a = d(t), f = d(o);
+    if (a !== f)
+      if (l(a) && l(f))
+        for (let s = 0; s < e.length; s++) {
+          const i = e[s];
+          typeof i == "string" && (e[s] = parseFloat(i));
+        }
+      else
+        this.needsMeasurement = !0;
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: r } = this, n = [];
+    for (let t = 0; t < e.length; t++)
+      h(e[t]) && n.push(t);
+    n.length && K(e, n, r);
+  }
+  measureInitialState() {
+    const { element: e, unresolvedKeyframes: r, name: n } = this;
+    if (!e || !e.current)
+      return;
+    n === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = u[n](e.measureViewportBox(), window.getComputedStyle(e.current)), r[0] = this.measuredOrigin;
+    const t = r[r.length - 1];
+    t !== void 0 && e.getValue(n, t).jump(t, !1);
+  }
+  measureEndState() {
+    var e;
+    const { element: r, name: n, unresolvedKeyframes: t } = this;
+    if (!r || !r.current)
+      return;
+    const o = r.getValue(n);
+    o && o.jump(this.measuredOrigin, !1);
+    const a = t.length - 1, f = t[a];
+    t[a] = u[n](r.measureViewportBox(), window.getComputedStyle(r.current)), f !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = f), !((e = this.removedTransforms) === null || e === void 0) && e.length && this.removedTransforms.forEach(([s, i]) => {
+      r.getValue(s).set(i);
+    }), this.resolveNoneKeyframes();
+  }
+}
+export {
+  b as DOMKeyframesResolver
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs

@@ -0,0 +1,19 @@
+import { VisualElement as o } from "../VisualElement.mjs";
+import { DOMKeyframesResolver as s } from "./DOMKeyframesResolver.mjs";
+class l extends o {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = s;
+  }
+  sortInstanceNodePosition(e, t) {
+    return e.compareDocumentPosition(t) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(e, t) {
+    return e.style ? e.style[t] : void 0;
+  }
+  removeValueFromRenderState(e, { vars: t, style: r }) {
+    delete t[e], delete r[e];
+  }
+}
+export {
+  l as DOMVisualElement
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/resize/handle-element.mjs

@@ -0,0 +1,46 @@
+import { resolveElements as l } from "../utils/resolve-element.mjs";
+const s = /* @__PURE__ */ new WeakMap();
+let o;
+function f(e, t) {
+  if (t) {
+    const { inlineSize: r, blockSize: i } = t[0];
+    return { width: r, height: i };
+  } else return e instanceof SVGElement && "getBBox" in e ? e.getBBox() : {
+    width: e.offsetWidth,
+    height: e.offsetHeight
+  };
+}
+function d({ target: e, contentRect: t, borderBoxSize: r }) {
+  var i;
+  (i = s.get(e)) === null || i === void 0 || i.forEach((n) => {
+    n({
+      target: e,
+      contentSize: t,
+      get size() {
+        return f(e, r);
+      }
+    });
+  });
+}
+function u(e) {
+  e.forEach(d);
+}
+function v() {
+  typeof ResizeObserver > "u" || (o = new ResizeObserver(u));
+}
+function h(e, t) {
+  o || v();
+  const r = l(e);
+  return r.forEach((i) => {
+    let n = s.get(i);
+    n || (n = /* @__PURE__ */ new Set(), s.set(i, n)), n.add(t), o == null || o.observe(i);
+  }), () => {
+    r.forEach((i) => {
+      const n = s.get(i);
+      n == null || n.delete(t), n != null && n.size || o == null || o.unobserve(i);
+    });
+  };
+}
+export {
+  h as resizeElement
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/resize/handle-window.mjs

@@ -0,0 +1,23 @@
+const i = /* @__PURE__ */ new Set();
+let n;
+function o() {
+  n = () => {
+    const e = {
+      width: window.innerWidth,
+      height: window.innerHeight
+    }, t = {
+      target: window,
+      size: e,
+      contentSize: e
+    };
+    i.forEach((d) => d(t));
+  }, window.addEventListener("resize", n);
+}
+function w(e) {
+  return i.add(e), n || o(), () => {
+    i.delete(e), !i.size && n && (n = void 0);
+  };
+}
+export {
+  w as resizeWindow
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/resize/index.mjs

@@ -0,0 +1,8 @@
+import { resizeElement as o } from "./handle-element.mjs";
+import { resizeWindow as i } from "./handle-window.mjs";
+function f(e, r) {
+  return typeof e == "function" ? i(e) : o(e, r);
+}
+export {
+  f as resize
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/scroll/index.mjs

@@ -0,0 +1,46 @@
+import { scrollInfo as c } from "./track.mjs";
+import { observeTimeline as f } from "./observe.mjs";
+import { supportsScrollTimeline as o } from "./supports.mjs";
+function g({ source: e, container: r, axis: t = "y" }) {
+  e && (r = e);
+  const u = { value: 0 }, n = c((m) => {
+    u.value = m[t].progress * 100;
+  }, { container: r, axis: t });
+  return { currentTime: u, cancel: n };
+}
+const l = /* @__PURE__ */ new Map();
+function s({ source: e, container: r = document.documentElement, axis: t = "y" } = {}) {
+  e && (r = e), l.has(r) || l.set(r, {});
+  const u = l.get(r);
+  return u[t] || (u[t] = o() ? new ScrollTimeline({ source: r, axis: t }) : g({ source: r, axis: t })), u[t];
+}
+function T(e) {
+  return e.length === 2;
+}
+function i(e) {
+  return e && (e.target || e.offset);
+}
+function h(e, r) {
+  return T(e) || i(r) ? c((t) => {
+    e(t[r.axis].progress, t);
+  }, r) : f(e, s(r));
+}
+function p(e, r) {
+  if (i(r))
+    return e.pause(), c((t) => {
+      e.time = e.duration * t[r.axis].progress;
+    }, r);
+  {
+    const t = s(r);
+    return e.attachTimeline(t, (u) => (u.pause(), f((n) => {
+      u.time = u.duration * n;
+    }, t)));
+  }
+}
+function k(e, { axis: r = "y", ...t } = {}) {
+  const u = { axis: r, ...t };
+  return typeof e == "function" ? h(e, u) : p(e, u);
+}
+export {
+  k as scroll
+};