motion-v 0.3.0 → 0.3.1-beta.1

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/value-types/type-int.mjs

@@ -0,0 +1,8 @@
+import { number } from "../../../value/types/numbers/index.mjs";
+const int = {
+  ...number,
+  transform: Math.round
+};
+export {
+  int
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/viewport/index.mjs

@@ -0,0 +1,37 @@
+import { resolveElements } from "../utils/resolve-element.mjs";
+const thresholds = {
+  some: 0,
+  all: 1
+};
+function inView(elementOrSelector, onStart, { root, margin: rootMargin, amount = "some" } = {}) {
+  const elements = resolveElements(elementOrSelector);
+  const activeIntersections = /* @__PURE__ */ new WeakMap();
+  const onIntersectionChange = (entries) => {
+    entries.forEach((entry) => {
+      const onEnd = activeIntersections.get(entry.target);
+      if (entry.isIntersecting === Boolean(onEnd))
+        return;
+      if (entry.isIntersecting) {
+        const newOnEnd = onStart(entry);
+        if (typeof newOnEnd === "function") {
+          activeIntersections.set(entry.target, newOnEnd);
+        } else {
+          observer.unobserve(entry.target);
+        }
+      } else if (onEnd) {
+        onEnd(entry);
+        activeIntersections.delete(entry.target);
+      }
+    });
+  };
+  const observer = new IntersectionObserver(onIntersectionChange, {
+    root,
+    rootMargin,
+    threshold: typeof amount === "number" ? amount : thresholds[amount]
+  });
+  elements.forEach((element) => observer.observe(element));
+  return () => observer.disconnect();
+}
+export {
+  inView
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/html/HTMLVisualElement.mjs

@@ -0,0 +1,55 @@
+import { buildHTMLStyles } from "./utils/build-styles.mjs";
+import { isCSSVariableName } from "../dom/utils/is-css-variable.mjs";
+import { transformProps } from "./utils/transform.mjs";
+import { scrapeMotionValuesFromProps } from "./utils/scrape-motion-values.mjs";
+import { renderHTML } from "./utils/render.mjs";
+import { getDefaultValueType } from "../dom/value-types/defaults.mjs";
+import { measureViewportBox } from "../../projection/utils/measure.mjs";
+import { DOMVisualElement } from "../dom/DOMVisualElement.mjs";
+import { isMotionValue } from "../../value/utils/is-motion-value.mjs";
+function getComputedStyle(element) {
+  return window.getComputedStyle(element);
+}
+class HTMLVisualElement extends DOMVisualElement {
+  constructor() {
+    super(...arguments);
+    this.type = "html";
+    this.renderInstance = renderHTML;
+  }
+  readValueFromInstance(instance, key) {
+    if (transformProps.has(key)) {
+      const defaultType = getDefaultValueType(key);
+      return defaultType ? defaultType.default || 0 : 0;
+    } else {
+      const computedStyle = getComputedStyle(instance);
+      const value = (isCSSVariableName(key) ? computedStyle.getPropertyValue(key) : computedStyle[key]) || 0;
+      return typeof value === "string" ? value.trim() : value;
+    }
+  }
+  measureInstanceViewportBox(instance, { transformPagePoint }) {
+    return measureViewportBox(instance, transformPagePoint);
+  }
+  build(renderState, latestValues, props) {
+    buildHTMLStyles(renderState, latestValues, props.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+    return scrapeMotionValuesFromProps(props, prevProps, visualElement);
+  }
+  handleChildMotionValue() {
+    if (this.childSubscription) {
+      this.childSubscription();
+      delete this.childSubscription;
+    }
+    const { children } = this.props;
+    if (isMotionValue(children)) {
+      this.childSubscription = children.on("change", (latest) => {
+        if (this.current)
+          this.current.textContent = `${latest}`;
+      });
+    }
+  }
+}
+export {
+  HTMLVisualElement,
+  getComputedStyle
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/html/utils/build-styles.mjs

@@ -0,0 +1,42 @@
+import { buildTransform } from "./build-transform.mjs";
+import { isCSSVariableName } from "../../dom/utils/is-css-variable.mjs";
+import { transformProps } from "./transform.mjs";
+import { getValueAsType } from "../../dom/value-types/get-as-type.mjs";
+import { numberValueTypes } from "../../dom/value-types/number.mjs";
+function buildHTMLStyles(state, latestValues, transformTemplate) {
+  const { style, vars, transformOrigin } = state;
+  let hasTransform = false;
+  let hasTransformOrigin = false;
+  for (const key in latestValues) {
+    const value = latestValues[key];
+    if (transformProps.has(key)) {
+      hasTransform = true;
+      continue;
+    } else if (isCSSVariableName(key)) {
+      vars[key] = value;
+      continue;
+    } else {
+      const valueAsType = getValueAsType(value, numberValueTypes[key]);
+      if (key.startsWith("origin")) {
+        hasTransformOrigin = true;
+        transformOrigin[key] = valueAsType;
+      } else {
+        style[key] = valueAsType;
+      }
+    }
+  }
+  if (!latestValues.transform) {
+    if (hasTransform || transformTemplate) {
+      style.transform = buildTransform(latestValues, state.transform, transformTemplate);
+    } else if (style.transform) {
+      style.transform = "none";
+    }
+  }
+  if (hasTransformOrigin) {
+    const { originX = "50%", originY = "50%", originZ = 0 } = transformOrigin;
+    style.transformOrigin = `${originX} ${originY} ${originZ}`;
+  }
+}
+export {
+  buildHTMLStyles
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/html/utils/build-transform.mjs

@@ -0,0 +1,47 @@
+import { transformPropOrder } from "./transform.mjs";
+import { getValueAsType } from "../../dom/value-types/get-as-type.mjs";
+import { numberValueTypes } from "../../dom/value-types/number.mjs";
+const translateAlias = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+};
+const numTransforms = transformPropOrder.length;
+function buildTransform(latestValues, transform, transformTemplate) {
+  let transformString = "";
+  let transformIsDefault = true;
+  for (let i = 0; i < numTransforms; i++) {
+    const key = transformPropOrder[i];
+    const value = latestValues[key];
+    if (value === void 0)
+      continue;
+    let valueIsDefault = true;
+    if (typeof value === "number") {
+      valueIsDefault = value === (key.startsWith("scale") ? 1 : 0);
+    } else {
+      valueIsDefault = parseFloat(value) === 0;
+    }
+    if (!valueIsDefault || transformTemplate) {
+      const valueAsType = getValueAsType(value, numberValueTypes[key]);
+      if (!valueIsDefault) {
+        transformIsDefault = false;
+        const transformName = translateAlias[key] || key;
+        transformString += `${transformName}(${valueAsType}) `;
+      }
+      if (transformTemplate) {
+        transform[key] = valueAsType;
+      }
+    }
+  }
+  transformString = transformString.trim();
+  if (transformTemplate) {
+    transformString = transformTemplate(transform, transformIsDefault ? "" : transformString);
+  } else if (transformIsDefault) {
+    transformString = "none";
+  }
+  return transformString;
+}
+export {
+  buildTransform
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs

@@ -0,0 +1,22 @@
+import { analyseComplexValue } from "../../../value/types/complex/index.mjs";
+import { getAnimatableNone } from "../../dom/value-types/animatable-none.mjs";
+const invalidTemplates = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {
+  let i = 0;
+  let animatableTemplate = void 0;
+  while (i < unresolvedKeyframes.length && !animatableTemplate) {
+    const keyframe = unresolvedKeyframes[i];
+    if (typeof keyframe === "string" && !invalidTemplates.has(keyframe) && analyseComplexValue(keyframe).values.length) {
+      animatableTemplate = unresolvedKeyframes[i];
+    }
+    i++;
+  }
+  if (animatableTemplate && name) {
+    for (const noneIndex of noneKeyframeIndexes) {
+      unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);
+    }
+  }
+}
+export {
+  makeNoneKeyframesAnimatable
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/html/utils/render.mjs

@@ -0,0 +1,9 @@
+function renderHTML(element, { style, vars }, styleProp, projection) {
+  Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));
+  for (const key in vars) {
+    element.style.setProperty(key, vars[key]);
+  }
+}
+export {
+  renderHTML
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs

@@ -0,0 +1,16 @@
+import { isForcedMotionValue } from "../../../motion/utils/is-forced-motion-value.mjs";
+import { isMotionValue } from "../../../value/utils/is-motion-value.mjs";
+function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+  var _a;
+  const { style } = props;
+  const newValues = {};
+  for (const key in style) {
+    if (isMotionValue(style[key]) || prevProps.style && isMotionValue(prevProps.style[key]) || isForcedMotionValue(key, props) || ((_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.getValue(key)) === null || _a === void 0 ? void 0 : _a.liveStyle) !== void 0) {
+      newValues[key] = style[key];
+    }
+  }
+  return newValues;
+}
+export {
+  scrapeMotionValuesFromProps
+};

package/dist/es/{node_modules/.pnpm/framer-motion@11.11.11/node_modules → external/.pnpm/framer-motion@11.11.11/external}/framer-motion/dist/es/render/html/utils/transform.mjs

@@ -1,4 +1,4 @@
-const t = [
+const transformPropOrder = [
   "transformPerspective",
   "x",
   "y",
@@ -16,8 +16,9 @@ const t = [
   "skew",
   "skewX",
   "skewY"
-], e = new Set(t);
+];
+const transformProps = new Set(transformPropOrder);
 export {
-  t as transformPropOrder,
-  e as transformProps
+  transformPropOrder,
+  transformProps
 };

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/object/ObjectVisualElement.mjs

@@ -0,0 +1,41 @@
+import { createBox } from "../../projection/geometry/models.mjs";
+import { VisualElement } from "../VisualElement.mjs";
+function isObjectKey(key, object) {
+  return key in object;
+}
+class ObjectVisualElement extends VisualElement {
+  constructor() {
+    super(...arguments);
+    this.type = "object";
+  }
+  readValueFromInstance(instance, key) {
+    if (isObjectKey(key, instance)) {
+      const value = instance[key];
+      if (typeof value === "string" || typeof value === "number") {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  getBaseTargetFromProps() {
+    return void 0;
+  }
+  removeValueFromRenderState(key, renderState) {
+    delete renderState.output[key];
+  }
+  measureInstanceViewportBox() {
+    return createBox();
+  }
+  build(renderState, latestValues) {
+    Object.assign(renderState.output, latestValues);
+  }
+  renderInstance(instance, { output }) {
+    Object.assign(instance, output);
+  }
+  sortInstanceNodePosition() {
+    return 0;
+  }
+}
+export {
+  ObjectVisualElement
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/store.mjs

@@ -0,0 +1,4 @@
+const visualElementStore = /* @__PURE__ */ new WeakMap();
+export {
+  visualElementStore
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/svg/SVGVisualElement.mjs

@@ -0,0 +1,45 @@
+import { scrapeMotionValuesFromProps } from "./utils/scrape-motion-values.mjs";
+import { DOMVisualElement } from "../dom/DOMVisualElement.mjs";
+import { buildSVGAttrs } from "./utils/build-attrs.mjs";
+import { camelToDash } from "../dom/utils/camel-to-dash.mjs";
+import { camelCaseAttributes } from "./utils/camel-case-attrs.mjs";
+import { transformProps } from "../html/utils/transform.mjs";
+import { renderSVG } from "./utils/render.mjs";
+import { getDefaultValueType } from "../dom/value-types/defaults.mjs";
+import { createBox } from "../../projection/geometry/models.mjs";
+import { isSVGTag } from "./utils/is-svg-tag.mjs";
+class SVGVisualElement extends DOMVisualElement {
+  constructor() {
+    super(...arguments);
+    this.type = "svg";
+    this.isSVGTag = false;
+    this.measureInstanceViewportBox = createBox;
+  }
+  getBaseTargetFromProps(props, key) {
+    return props[key];
+  }
+  readValueFromInstance(instance, key) {
+    if (transformProps.has(key)) {
+      const defaultType = getDefaultValueType(key);
+      return defaultType ? defaultType.default || 0 : 0;
+    }
+    key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
+    return instance.getAttribute(key);
+  }
+  scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+    return scrapeMotionValuesFromProps(props, prevProps, visualElement);
+  }
+  build(renderState, latestValues, props) {
+    buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate);
+  }
+  renderInstance(instance, renderState, styleProp, projection) {
+    renderSVG(instance, renderState, styleProp, projection);
+  }
+  mount(instance) {
+    this.isSVGTag = isSVGTag(instance.tagName);
+    super.mount(instance);
+  }
+}
+export {
+  SVGVisualElement
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/svg/utils/build-attrs.mjs

@@ -0,0 +1,46 @@
+import { buildHTMLStyles } from "../../html/utils/build-styles.mjs";
+import { calcSVGTransformOrigin } from "./transform-origin.mjs";
+import { buildSVGPath } from "./path.mjs";
+function buildSVGAttrs(state, {
+  attrX,
+  attrY,
+  attrScale,
+  originX,
+  originY,
+  pathLength,
+  pathSpacing = 1,
+  pathOffset = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...latest
+}, isSVGTag, transformTemplate) {
+  buildHTMLStyles(state, latest, transformTemplate);
+  if (isSVGTag) {
+    if (state.style.viewBox) {
+      state.attrs.viewBox = state.style.viewBox;
+    }
+    return;
+  }
+  state.attrs = state.style;
+  state.style = {};
+  const { attrs, style, dimensions } = state;
+  if (attrs.transform) {
+    if (dimensions)
+      style.transform = attrs.transform;
+    delete attrs.transform;
+  }
+  if (dimensions && (originX !== void 0 || originY !== void 0 || style.transform)) {
+    style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== void 0 ? originX : 0.5, originY !== void 0 ? originY : 0.5);
+  }
+  if (attrX !== void 0)
+    attrs.x = attrX;
+  if (attrY !== void 0)
+    attrs.y = attrY;
+  if (attrScale !== void 0)
+    attrs.scale = attrScale;
+  if (pathLength !== void 0) {
+    buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);
+  }
+}
+export {
+  buildSVGAttrs
+};

package/dist/es/{node_modules/.pnpm/framer-motion@11.11.11/node_modules → external/.pnpm/framer-motion@11.11.11/external}/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs

@@ -1,4 +1,4 @@
-const e = /* @__PURE__ */ new Set([
+const camelCaseAttributes = /* @__PURE__ */ new Set([
   "baseFrequency",
   "diffuseConstant",
   "kernelMatrix",
@@ -24,5 +24,5 @@ const e = /* @__PURE__ */ new Set([
   "lengthAdjust"
 ]);
 export {
-  e as camelCaseAttributes
+  camelCaseAttributes
 };

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/svg/utils/is-svg-tag.mjs

@@ -0,0 +1,4 @@
+const isSVGTag = (tag) => typeof tag === "string" && tag.toLowerCase() === "svg";
+export {
+  isSVGTag
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/svg/utils/path.mjs

@@ -0,0 +1,20 @@
+import { px } from "../../../value/types/numbers/units.mjs";
+const dashKeys = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+};
+const camelKeys = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function buildSVGPath(attrs, length, spacing = 1, offset = 0, useDashCase = true) {
+  attrs.pathLength = 1;
+  const keys = useDashCase ? dashKeys : camelKeys;
+  attrs[keys.offset] = px.transform(-offset);
+  const pathLength = px.transform(length);
+  const pathSpacing = px.transform(spacing);
+  attrs[keys.array] = `${pathLength} ${pathSpacing}`;
+}
+export {
+  buildSVGPath
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/svg/utils/render.mjs

@@ -0,0 +1,12 @@
+import { camelToDash } from "../../dom/utils/camel-to-dash.mjs";
+import { renderHTML } from "../../html/utils/render.mjs";
+import { camelCaseAttributes } from "./camel-case-attrs.mjs";
+function renderSVG(element, renderState, _styleProp, projection) {
+  renderHTML(element, renderState, void 0, projection);
+  for (const key in renderState.attrs) {
+    element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);
+  }
+}
+export {
+  renderSVG
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs

@@ -0,0 +1,16 @@
+import { isMotionValue } from "../../../value/utils/is-motion-value.mjs";
+import { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from "../../html/utils/scrape-motion-values.mjs";
+import { transformPropOrder } from "../../html/utils/transform.mjs";
+function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+  const newValues = scrapeMotionValuesFromProps$1(props, prevProps, visualElement);
+  for (const key in props) {
+    if (isMotionValue(props[key]) || isMotionValue(prevProps[key])) {
+      const targetKey = transformPropOrder.indexOf(key) !== -1 ? "attr" + key.charAt(0).toUpperCase() + key.substring(1) : key;
+      newValues[targetKey] = props[key];
+    }
+  }
+  return newValues;
+}
+export {
+  scrapeMotionValuesFromProps
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/svg/utils/transform-origin.mjs

@@ -0,0 +1,12 @@
+import { px } from "../../../value/types/numbers/units.mjs";
+function calcOrigin(origin, offset, size) {
+  return typeof origin === "string" ? origin : px.transform(offset + size * origin);
+}
+function calcSVGTransformOrigin(dimensions, originX, originY) {
+  const pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);
+  const pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);
+  return `${pxOriginX} ${pxOriginY}`;
+}
+export {
+  calcSVGTransformOrigin
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/utils/KeyframesResolver.mjs

@@ -0,0 +1,134 @@
+import { removeNonTranslationalTransform } from "../dom/utils/unit-conversion.mjs";
+import { frame } from "../../frameloop/frame.mjs";
+const toResolve = /* @__PURE__ */ new Set();
+let isScheduled = false;
+let anyNeedsMeasurement = false;
+function measureAllKeyframes() {
+  if (anyNeedsMeasurement) {
+    const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);
+    const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));
+    const transformsToRestore = /* @__PURE__ */ new Map();
+    elementsToMeasure.forEach((element) => {
+      const removedTransforms = removeNonTranslationalTransform(element);
+      if (!removedTransforms.length)
+        return;
+      transformsToRestore.set(element, removedTransforms);
+      element.render();
+    });
+    resolversToMeasure.forEach((resolver) => resolver.measureInitialState());
+    elementsToMeasure.forEach((element) => {
+      element.render();
+      const restore = transformsToRestore.get(element);
+      if (restore) {
+        restore.forEach(([key, value]) => {
+          var _a;
+          (_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);
+        });
+      }
+    });
+    resolversToMeasure.forEach((resolver) => resolver.measureEndState());
+    resolversToMeasure.forEach((resolver) => {
+      if (resolver.suspendedScrollY !== void 0) {
+        window.scrollTo(0, resolver.suspendedScrollY);
+      }
+    });
+  }
+  anyNeedsMeasurement = false;
+  isScheduled = false;
+  toResolve.forEach((resolver) => resolver.complete());
+  toResolve.clear();
+}
+function readAllKeyframes() {
+  toResolve.forEach((resolver) => {
+    resolver.readKeyframes();
+    if (resolver.needsMeasurement) {
+      anyNeedsMeasurement = true;
+    }
+  });
+}
+function flushKeyframeResolvers() {
+  readAllKeyframes();
+  measureAllKeyframes();
+}
+class KeyframeResolver {
+  constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {
+    this.isComplete = false;
+    this.isAsync = false;
+    this.needsMeasurement = false;
+    this.isScheduled = false;
+    this.unresolvedKeyframes = [...unresolvedKeyframes];
+    this.onComplete = onComplete;
+    this.name = name;
+    this.motionValue = motionValue;
+    this.element = element;
+    this.isAsync = isAsync;
+  }
+  scheduleResolve() {
+    this.isScheduled = true;
+    if (this.isAsync) {
+      toResolve.add(this);
+      if (!isScheduled) {
+        isScheduled = true;
+        frame.read(readAllKeyframes);
+        frame.resolveKeyframes(measureAllKeyframes);
+      }
+    } else {
+      this.readKeyframes();
+      this.complete();
+    }
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes, name, element, motionValue } = this;
+    for (let i = 0; i < unresolvedKeyframes.length; i++) {
+      if (unresolvedKeyframes[i] === null) {
+        if (i === 0) {
+          const currentValue = motionValue === null || motionValue === void 0 ? void 0 : motionValue.get();
+          const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
+          if (currentValue !== void 0) {
+            unresolvedKeyframes[0] = currentValue;
+          } else if (element && name) {
+            const valueAsRead = element.readValue(name, finalKeyframe);
+            if (valueAsRead !== void 0 && valueAsRead !== null) {
+              unresolvedKeyframes[0] = valueAsRead;
+            }
+          }
+          if (unresolvedKeyframes[0] === void 0) {
+            unresolvedKeyframes[0] = finalKeyframe;
+          }
+          if (motionValue && currentValue === void 0) {
+            motionValue.set(unresolvedKeyframes[0]);
+          }
+        } else {
+          unresolvedKeyframes[i] = unresolvedKeyframes[i - 1];
+        }
+      }
+    }
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete() {
+    this.isComplete = true;
+    this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);
+    toResolve.delete(this);
+  }
+  cancel() {
+    if (!this.isComplete) {
+      this.isScheduled = false;
+      toResolve.delete(this);
+    }
+  }
+  resume() {
+    if (!this.isComplete)
+      this.scheduleResolve();
+  }
+}
+export {
+  KeyframeResolver,
+  flushKeyframeResolvers
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/utils/is-controlling-variants.mjs

@@ -0,0 +1,13 @@
+import { isAnimationControls } from "../../animation/utils/is-animation-controls.mjs";
+import { isVariantLabel } from "./is-variant-label.mjs";
+import { variantProps } from "./variant-props.mjs";
+function isControllingVariants(props) {
+  return isAnimationControls(props.animate) || variantProps.some((name) => isVariantLabel(props[name]));
+}
+function isVariantNode(props) {
+  return Boolean(isControllingVariants(props) || props.variants);
+}
+export {
+  isControllingVariants,
+  isVariantNode
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/utils/is-variant-label.mjs

@@ -0,0 +1,6 @@
+function isVariantLabel(v) {
+  return typeof v === "string" || Array.isArray(v);
+}
+export {
+  isVariantLabel
+};