motion-v 0.2.6 → 0.3.1-beta.1

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/info.mjs

@@ -0,0 +1,51 @@
+import { progress } from "../../../utils/progress.mjs";
+import { velocityPerSecond } from "../../../utils/velocity-per-second.mjs";
+const maxElapsed = 50;
+const createAxisInfo = () => ({
+  current: 0,
+  offset: [],
+  progress: 0,
+  scrollLength: 0,
+  targetOffset: 0,
+  targetLength: 0,
+  containerLength: 0,
+  velocity: 0
+});
+const createScrollInfo = () => ({
+  time: 0,
+  x: createAxisInfo(),
+  y: createAxisInfo()
+});
+const keys = {
+  x: {
+    length: "Width",
+    position: "Left"
+  },
+  y: {
+    length: "Height",
+    position: "Top"
+  }
+};
+function updateAxisInfo(element, axisName, info, time) {
+  const axis = info[axisName];
+  const { length, position } = keys[axisName];
+  const prev = axis.current;
+  const prevTime = info.time;
+  axis.current = element[`scroll${position}`];
+  axis.scrollLength = element[`scroll${length}`] - element[`client${length}`];
+  axis.offset.length = 0;
+  axis.offset[0] = 0;
+  axis.offset[1] = axis.scrollLength;
+  axis.progress = progress(0, axis.scrollLength, axis.current);
+  const elapsed = time - prevTime;
+  axis.velocity = elapsed > maxElapsed ? 0 : velocityPerSecond(axis.current - prev, elapsed);
+}
+function updateScrollInfo(element, info, time) {
+  updateAxisInfo(element, "x", info, time);
+  updateAxisInfo(element, "y", info, time);
+  info.time = time;
+}
+export {
+  createScrollInfo,
+  updateScrollInfo
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/observe.mjs

@@ -0,0 +1,18 @@
+import { frame, cancelFrame } from "../../../frameloop/frame.mjs";
+function observeTimeline(update, timeline) {
+  let prevProgress;
+  const onFrame = () => {
+    const { currentTime } = timeline;
+    const percentage = currentTime === null ? 0 : currentTime.value;
+    const progress = percentage / 100;
+    if (prevProgress !== progress) {
+      update(progress);
+    }
+    prevProgress = progress;
+  };
+  frame.update(onFrame, true);
+  return () => cancelFrame(onFrame);
+}
+export {
+  observeTimeline
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/offsets/edge.mjs

@@ -0,0 +1,33 @@
+const namedEdges = {
+  start: 0,
+  center: 0.5,
+  end: 1
+};
+function resolveEdge(edge, length, inset = 0) {
+  let delta = 0;
+  if (edge in namedEdges) {
+    edge = namedEdges[edge];
+  }
+  if (typeof edge === "string") {
+    const asNumber = parseFloat(edge);
+    if (edge.endsWith("px")) {
+      delta = asNumber;
+    } else if (edge.endsWith("%")) {
+      edge = asNumber / 100;
+    } else if (edge.endsWith("vw")) {
+      delta = asNumber / 100 * document.documentElement.clientWidth;
+    } else if (edge.endsWith("vh")) {
+      delta = asNumber / 100 * document.documentElement.clientHeight;
+    } else {
+      edge = asNumber;
+    }
+  }
+  if (typeof edge === "number") {
+    delta = length * edge;
+  }
+  return inset + delta;
+}
+export {
+  namedEdges,
+  resolveEdge
+};

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

@@ -0,0 +1,38 @@
+import { calcInset } from "./inset.mjs";
+import { ScrollOffset } from "./presets.mjs";
+import { resolveOffset } from "./offset.mjs";
+import { interpolate } from "../../../../utils/interpolate.mjs";
+import { defaultOffset } from "../../../../utils/offsets/default.mjs";
+const point = { x: 0, y: 0 };
+function getTargetSize(target) {
+  return "getBBox" in target && target.tagName !== "svg" ? target.getBBox() : { width: target.clientWidth, height: target.clientHeight };
+}
+function resolveOffsets(container, info, options) {
+  const { offset: offsetDefinition = ScrollOffset.All } = options;
+  const { target = container, axis = "y" } = options;
+  const lengthLabel = axis === "y" ? "height" : "width";
+  const inset = target !== container ? calcInset(target, container) : point;
+  const targetSize = target === container ? { width: container.scrollWidth, height: container.scrollHeight } : getTargetSize(target);
+  const containerSize = {
+    width: container.clientWidth,
+    height: container.clientHeight
+  };
+  info[axis].offset.length = 0;
+  let hasChanged = !info[axis].interpolate;
+  const numOffsets = offsetDefinition.length;
+  for (let i = 0; i < numOffsets; i++) {
+    const offset = resolveOffset(offsetDefinition[i], containerSize[lengthLabel], targetSize[lengthLabel], inset[axis]);
+    if (!hasChanged && offset !== info[axis].interpolatorOffsets[i]) {
+      hasChanged = true;
+    }
+    info[axis].offset[i] = offset;
+  }
+  if (hasChanged) {
+    info[axis].interpolate = interpolate(info[axis].offset, defaultOffset(offsetDefinition));
+    info[axis].interpolatorOffsets = [...info[axis].offset];
+  }
+  info[axis].progress = info[axis].interpolate(info[axis].current);
+}
+export {
+  resolveOffsets
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/offsets/inset.mjs

@@ -0,0 +1,36 @@
+function calcInset(element, container) {
+  const inset = { x: 0, y: 0 };
+  let current = element;
+  while (current && current !== container) {
+    if (current instanceof HTMLElement) {
+      inset.x += current.offsetLeft;
+      inset.y += current.offsetTop;
+      current = current.offsetParent;
+    } else if (current.tagName === "svg") {
+      const svgBoundingBox = current.getBoundingClientRect();
+      current = current.parentElement;
+      const parentBoundingBox = current.getBoundingClientRect();
+      inset.x += svgBoundingBox.left - parentBoundingBox.left;
+      inset.y += svgBoundingBox.top - parentBoundingBox.top;
+    } else if (current instanceof SVGGraphicsElement) {
+      const { x, y } = current.getBBox();
+      inset.x += x;
+      inset.y += y;
+      let svg = null;
+      let parent = current.parentNode;
+      while (!svg) {
+        if (parent.tagName === "svg") {
+          svg = parent;
+        }
+        parent = current.parentNode;
+      }
+      current = svg;
+    } else {
+      break;
+    }
+  }
+  return inset;
+}
+export {
+  calcInset
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/offsets/offset.mjs

@@ -0,0 +1,23 @@
+import { resolveEdge, namedEdges } from "./edge.mjs";
+const defaultOffset = [0, 0];
+function resolveOffset(offset, containerLength, targetLength, targetInset) {
+  let offsetDefinition = Array.isArray(offset) ? offset : defaultOffset;
+  let targetPoint = 0;
+  let containerPoint = 0;
+  if (typeof offset === "number") {
+    offsetDefinition = [offset, offset];
+  } else if (typeof offset === "string") {
+    offset = offset.trim();
+    if (offset.includes(" ")) {
+      offsetDefinition = offset.split(" ");
+    } else {
+      offsetDefinition = [offset, namedEdges[offset] ? offset : `0`];
+    }
+  }
+  targetPoint = resolveEdge(offsetDefinition[0], targetLength, targetInset);
+  containerPoint = resolveEdge(offsetDefinition[1], containerLength);
+  return targetPoint - containerPoint;
+}
+export {
+  resolveOffset
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/offsets/presets.mjs

@@ -0,0 +1,21 @@
+const ScrollOffset = {
+  Enter: [
+    [0, 1],
+    [1, 1]
+  ],
+  Exit: [
+    [0, 0],
+    [1, 0]
+  ],
+  Any: [
+    [1, 0],
+    [0, 1]
+  ],
+  All: [
+    [0, 0],
+    [1, 1]
+  ]
+};
+export {
+  ScrollOffset
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/on-scroll-handler.mjs

@@ -0,0 +1,39 @@
+import { warnOnce } from "../../../utils/warn-once.mjs";
+import { updateScrollInfo } from "./info.mjs";
+import { resolveOffsets } from "./offsets/index.mjs";
+function measure(container, target = container, info) {
+  info.x.targetOffset = 0;
+  info.y.targetOffset = 0;
+  if (target !== container) {
+    let node = target;
+    while (node && node !== container) {
+      info.x.targetOffset += node.offsetLeft;
+      info.y.targetOffset += node.offsetTop;
+      node = node.offsetParent;
+    }
+  }
+  info.x.targetLength = target === container ? target.scrollWidth : target.clientWidth;
+  info.y.targetLength = target === container ? target.scrollHeight : target.clientHeight;
+  info.x.containerLength = container.clientWidth;
+  info.y.containerLength = container.clientHeight;
+  if (process.env.NODE_ENV !== "production") {
+    if (container && target && target !== container) {
+      warnOnce(getComputedStyle(container).position !== "static", "Please ensure that the container has a non-static position, like 'relative', 'fixed', or 'absolute' to ensure scroll offset is calculated correctly.");
+    }
+  }
+}
+function createOnScrollHandler(element, onScroll, info, options = {}) {
+  return {
+    measure: () => measure(element, options.target, info),
+    update: (time) => {
+      updateScrollInfo(element, info, time);
+      if (options.offset || options.target) {
+        resolveOffsets(element, info, options);
+      }
+    },
+    notify: () => onScroll(info)
+  };
+}
+export {
+  createOnScrollHandler
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/supports.mjs

@@ -0,0 +1,5 @@
+import { memo } from "../../../utils/memo.mjs";
+const supportsScrollTimeline = memo(() => window.ScrollTimeline !== void 0);
+export {
+  supportsScrollTimeline
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/scroll/track.mjs

@@ -0,0 +1,67 @@
+import { resize } from "../resize/index.mjs";
+import { createScrollInfo } from "./info.mjs";
+import { createOnScrollHandler } from "./on-scroll-handler.mjs";
+import { frame, cancelFrame, frameData } from "../../../frameloop/frame.mjs";
+const scrollListeners = /* @__PURE__ */ new WeakMap();
+const resizeListeners = /* @__PURE__ */ new WeakMap();
+const onScrollHandlers = /* @__PURE__ */ new WeakMap();
+const getEventTarget = (element) => element === document.documentElement ? window : element;
+function scrollInfo(onScroll, { container = document.documentElement, ...options } = {}) {
+  let containerHandlers = onScrollHandlers.get(container);
+  if (!containerHandlers) {
+    containerHandlers = /* @__PURE__ */ new Set();
+    onScrollHandlers.set(container, containerHandlers);
+  }
+  const info = createScrollInfo();
+  const containerHandler = createOnScrollHandler(container, onScroll, info, options);
+  containerHandlers.add(containerHandler);
+  if (!scrollListeners.has(container)) {
+    const measureAll = () => {
+      for (const handler of containerHandlers)
+        handler.measure();
+    };
+    const updateAll = () => {
+      for (const handler of containerHandlers) {
+        handler.update(frameData.timestamp);
+      }
+    };
+    const notifyAll = () => {
+      for (const handler of containerHandlers)
+        handler.notify();
+    };
+    const listener2 = () => {
+      frame.read(measureAll, false, true);
+      frame.read(updateAll, false, true);
+      frame.update(notifyAll, false, true);
+    };
+    scrollListeners.set(container, listener2);
+    const target = getEventTarget(container);
+    window.addEventListener("resize", listener2, { passive: true });
+    if (container !== document.documentElement) {
+      resizeListeners.set(container, resize(container, listener2));
+    }
+    target.addEventListener("scroll", listener2, { passive: true });
+  }
+  const listener = scrollListeners.get(container);
+  frame.read(listener, false, true);
+  return () => {
+    var _a;
+    cancelFrame(listener);
+    const currentHandlers = onScrollHandlers.get(container);
+    if (!currentHandlers)
+      return;
+    currentHandlers.delete(containerHandler);
+    if (currentHandlers.size)
+      return;
+    const scrollListener = scrollListeners.get(container);
+    scrollListeners.delete(container);
+    if (scrollListener) {
+      getEventTarget(container).removeEventListener("scroll", scrollListener);
+      (_a = resizeListeners.get(container)) === null || _a === void 0 ? void 0 : _a();
+      window.removeEventListener("resize", scrollListener);
+    }
+  };
+}
+export {
+  scrollInfo
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs

@@ -0,0 +1,4 @@
+const camelToDash = (str) => str.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase();
+export {
+  camelToDash
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs

@@ -0,0 +1,31 @@
+import { invariant } from "../../../utils/errors.mjs";
+import { isNumericalString } from "../../../utils/is-numerical-string.mjs";
+import { isCSSVariableToken } from "./is-css-variable.mjs";
+const splitCSSVariableRegex = (
+  // eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words
+  /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u
+);
+function parseCSSVariable(current) {
+  const match = splitCSSVariableRegex.exec(current);
+  if (!match)
+    return [,];
+  const [, token1, token2, fallback] = match;
+  return [`--${token1 !== null && token1 !== void 0 ? token1 : token2}`, fallback];
+}
+const maxDepth = 4;
+function getVariableValue(current, element, depth = 1) {
+  invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property "${current}". This may indicate a circular fallback dependency.`);
+  const [token, fallback] = parseCSSVariable(current);
+  if (!token)
+    return;
+  const resolved = window.getComputedStyle(element).getPropertyValue(token);
+  if (resolved) {
+    const trimmed = resolved.trim();
+    return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;
+  }
+  return isCSSVariableToken(fallback) ? getVariableValue(fallback, element, depth + 1) : fallback;
+}
+export {
+  getVariableValue,
+  parseCSSVariable
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs

@@ -0,0 +1,14 @@
+const checkStringStartsWith = (token) => (key) => typeof key === "string" && key.startsWith(token);
+const isCSSVariableName = /* @__PURE__ */ checkStringStartsWith("--");
+const startsAsVariableToken = /* @__PURE__ */ checkStringStartsWith("var(--");
+const isCSSVariableToken = (value) => {
+  const startsWithToken = startsAsVariableToken(value);
+  if (!startsWithToken)
+    return false;
+  return singleCssVariableRegex.test(value.split("/*")[0].trim());
+};
+const singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+export {
+  isCSSVariableName,
+  isCSSVariableToken
+};

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

@@ -0,0 +1,6 @@
+function isSVGElement(element) {
+  return element instanceof SVGElement && element.tagName !== "svg";
+}
+export {
+  isSVGElement
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/utils/resolve-element.mjs

@@ -0,0 +1,23 @@
+import { invariant } from "../../../utils/errors.mjs";
+function resolveElements(elements, scope, selectorCache) {
+  var _a;
+  if (typeof elements === "string") {
+    let root = document;
+    if (scope) {
+      invariant(Boolean(scope.current), "Scope provided, but no element detected.");
+      root = scope.current;
+    }
+    if (selectorCache) {
+      (_a = selectorCache[elements]) !== null && _a !== void 0 ? _a : selectorCache[elements] = root.querySelectorAll(elements);
+      elements = selectorCache[elements];
+    } else {
+      elements = root.querySelectorAll(elements);
+    }
+  } else if (elements instanceof Element) {
+    elements = [elements];
+  }
+  return Array.from(elements || []);
+}
+export {
+  resolveElements
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs

@@ -0,0 +1,65 @@
+import { transformPropOrder } from "../../html/utils/transform.mjs";
+import { number } from "../../../value/types/numbers/index.mjs";
+import { px } from "../../../value/types/numbers/units.mjs";
+const positionalKeys = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  "x",
+  "y",
+  "translateX",
+  "translateY"
+]);
+const isNumOrPxType = (v) => v === number || v === px;
+const getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(", ")[pos]);
+const getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {
+  if (transform === "none" || !transform)
+    return 0;
+  const matrix3d = transform.match(/^matrix3d\((.+)\)$/u);
+  if (matrix3d) {
+    return getPosFromMatrix(matrix3d[1], pos3);
+  } else {
+    const matrix = transform.match(/^matrix\((.+)\)$/u);
+    if (matrix) {
+      return getPosFromMatrix(matrix[1], pos2);
+    } else {
+      return 0;
+    }
+  }
+};
+const transformKeys = /* @__PURE__ */ new Set(["x", "y", "z"]);
+const nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));
+function removeNonTranslationalTransform(visualElement) {
+  const removedTransforms = [];
+  nonTranslationalTransformKeys.forEach((key) => {
+    const value = visualElement.getValue(key);
+    if (value !== void 0) {
+      removedTransforms.push([key, value.get()]);
+      value.set(key.startsWith("scale") ? 1 : 0);
+    }
+  });
+  return removedTransforms;
+}
+const positionalValues = {
+  // Dimensions
+  width: ({ x }, { paddingLeft = "0", paddingRight = "0" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),
+  height: ({ y }, { paddingTop = "0", paddingBottom = "0" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),
+  top: (_bbox, { top }) => parseFloat(top),
+  left: (_bbox, { left }) => parseFloat(left),
+  bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),
+  right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),
+  // Transform
+  x: getTranslateFromMatrix(4, 13),
+  y: getTranslateFromMatrix(5, 14)
+};
+positionalValues.translateX = positionalValues.x;
+positionalValues.translateY = positionalValues.y;
+export {
+  isNumOrPxType,
+  positionalKeys,
+  positionalValues,
+  removeNonTranslationalTransform
+};

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

@@ -0,0 +1,12 @@
+import { complex } from "../../../value/types/complex/index.mjs";
+import { filter } from "../../../value/types/complex/filter.mjs";
+import { getDefaultValueType } from "./defaults.mjs";
+function getAnimatableNone(key, value) {
+  let defaultValueType = getDefaultValueType(key);
+  if (defaultValueType !== filter)
+    defaultValueType = complex;
+  return defaultValueType.getAnimatableNone ? defaultValueType.getAnimatableNone(value) : void 0;
+}
+export {
+  getAnimatableNone
+};

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

@@ -0,0 +1,25 @@
+import { color } from "../../../value/types/color/index.mjs";
+import { filter } from "../../../value/types/complex/filter.mjs";
+import { numberValueTypes } from "./number.mjs";
+const defaultValueTypes = {
+  ...numberValueTypes,
+  // Color props
+  color,
+  backgroundColor: color,
+  outlineColor: color,
+  fill: color,
+  stroke: color,
+  // Border props
+  borderColor: color,
+  borderTopColor: color,
+  borderRightColor: color,
+  borderBottomColor: color,
+  borderLeftColor: color,
+  filter,
+  WebkitFilter: filter
+};
+const getDefaultValueType = (key) => defaultValueTypes[key];
+export {
+  defaultValueTypes,
+  getDefaultValueType
+};

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

@@ -0,0 +1,10 @@
+import { number } from "../../../value/types/numbers/index.mjs";
+import { px, percent, degrees, vw, vh } from "../../../value/types/numbers/units.mjs";
+import { testValueType } from "./test.mjs";
+import { auto } from "./type-auto.mjs";
+const dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];
+const findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));
+export {
+  dimensionValueTypes,
+  findDimensionValueType
+};

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

@@ -0,0 +1,9 @@
+import { color } from "../../../value/types/color/index.mjs";
+import { complex } from "../../../value/types/complex/index.mjs";
+import { dimensionValueTypes } from "./dimensions.mjs";
+import { testValueType } from "./test.mjs";
+const valueTypes = [...dimensionValueTypes, color, complex];
+const findValueType = (v) => valueTypes.find(testValueType(v));
+export {
+  findValueType
+};

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

@@ -0,0 +1,6 @@
+const getValueAsType = (value, type) => {
+  return type && typeof value === "number" ? type.transform(value) : value;
+};
+export {
+  getValueAsType
+};

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

@@ -0,0 +1,41 @@
+import { px } from "../../../value/types/numbers/units.mjs";
+const browserNumberValueTypes = {
+  // Border props
+  borderWidth: px,
+  borderTopWidth: px,
+  borderRightWidth: px,
+  borderBottomWidth: px,
+  borderLeftWidth: px,
+  borderRadius: px,
+  radius: px,
+  borderTopLeftRadius: px,
+  borderTopRightRadius: px,
+  borderBottomRightRadius: px,
+  borderBottomLeftRadius: px,
+  // Positioning props
+  width: px,
+  maxWidth: px,
+  height: px,
+  maxHeight: px,
+  top: px,
+  right: px,
+  bottom: px,
+  left: px,
+  // Spacing props
+  padding: px,
+  paddingTop: px,
+  paddingRight: px,
+  paddingBottom: px,
+  paddingLeft: px,
+  margin: px,
+  marginTop: px,
+  marginRight: px,
+  marginBottom: px,
+  marginLeft: px,
+  // Misc
+  backgroundPositionX: px,
+  backgroundPositionY: px
+};
+export {
+  browserNumberValueTypes
+};

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

@@ -0,0 +1,18 @@
+import { alpha } from "../../../value/types/numbers/index.mjs";
+import { px } from "../../../value/types/numbers/units.mjs";
+import { browserNumberValueTypes } from "./number-browser.mjs";
+import { transformValueTypes } from "./transform.mjs";
+import { int } from "./type-int.mjs";
+const numberValueTypes = {
+  ...browserNumberValueTypes,
+  ...transformValueTypes,
+  zIndex: int,
+  size: px,
+  // SVG
+  fillOpacity: alpha,
+  strokeOpacity: alpha,
+  numOctaves: int
+};
+export {
+  numberValueTypes
+};

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

@@ -0,0 +1,4 @@
+const testValueType = (v) => (type) => type.test(v);
+export {
+  testValueType
+};

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

@@ -0,0 +1,31 @@
+import { scale, alpha } from "../../../value/types/numbers/index.mjs";
+import { degrees, px, progressPercentage } from "../../../value/types/numbers/units.mjs";
+const transformValueTypes = {
+  rotate: degrees,
+  rotateX: degrees,
+  rotateY: degrees,
+  rotateZ: degrees,
+  scale,
+  scaleX: scale,
+  scaleY: scale,
+  scaleZ: scale,
+  skew: degrees,
+  skewX: degrees,
+  skewY: degrees,
+  distance: px,
+  translateX: px,
+  translateY: px,
+  translateZ: px,
+  x: px,
+  y: px,
+  z: px,
+  perspective: px,
+  transformPerspective: px,
+  opacity: alpha,
+  originX: progressPercentage,
+  originY: progressPercentage,
+  originZ: px
+};
+export {
+  transformValueTypes
+};