motion-v 1.0.0-alpha.4 → 1.0.0-beta.0

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/NativeAnimationControls.mjs

@@ -0,0 +1,81 @@
+import "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { noop } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/noop.mjs";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/time-conversion.mjs";
+import { attachTimeline } from "./utils/attach-timeline.mjs";
+class NativeAnimationControls {
+  constructor(animation) {
+    this.animation = animation;
+  }
+  get duration() {
+    var _a, _b, _c;
+    const durationInMs = ((_b = (_a = this.animation) === null || _a === void 0 ? void 0 : _a.effect) === null || _b === void 0 ? void 0 : _b.getComputedTiming().duration) || ((_c = this.options) === null || _c === void 0 ? void 0 : _c.duration) || 300;
+    return millisecondsToSeconds(Number(durationInMs));
+  }
+  get time() {
+    var _a;
+    if (this.animation) {
+      return millisecondsToSeconds(((_a = this.animation) === null || _a === void 0 ? void 0 : _a.currentTime) || 0);
+    }
+    return 0;
+  }
+  set time(newTime) {
+    if (this.animation) {
+      this.animation.currentTime = secondsToMilliseconds(newTime);
+    }
+  }
+  get speed() {
+    return this.animation ? this.animation.playbackRate : 1;
+  }
+  set speed(newSpeed) {
+    if (this.animation) {
+      this.animation.playbackRate = newSpeed;
+    }
+  }
+  get state() {
+    return this.animation ? this.animation.playState : "finished";
+  }
+  get startTime() {
+    return this.animation ? this.animation.startTime : null;
+  }
+  get finished() {
+    return this.animation ? this.animation.finished : Promise.resolve();
+  }
+  play() {
+    this.animation && this.animation.play();
+  }
+  pause() {
+    this.animation && this.animation.pause();
+  }
+  stop() {
+    if (!this.animation || this.state === "idle" || this.state === "finished") {
+      return;
+    }
+    if (this.animation.commitStyles) {
+      this.animation.commitStyles();
+    }
+    this.cancel();
+  }
+  flatten() {
+    var _a, _b;
+    if (!this.animation || !((_a = this.options) === null || _a === void 0 ? void 0 : _a.allowFlatten))
+      return;
+    (_b = this.animation.effect) === null || _b === void 0 ? void 0 : _b.updateTiming({ easing: "linear" });
+  }
+  attachTimeline(timeline) {
+    if (this.animation)
+      attachTimeline(this.animation, timeline);
+    return noop;
+  }
+  complete() {
+    this.animation && this.animation.finish();
+  }
+  cancel() {
+    try {
+      this.animation && this.animation.cancel();
+    } catch (e) {
+    }
+  }
+}
+export {
+  NativeAnimationControls
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/utils/attach-timeline.mjs

@@ -0,0 +1,7 @@
+function attachTimeline(animation, timeline) {
+  animation.timeline = timeline;
+  animation.onfinish = null;
+}
+export {
+  attachTimeline
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/utils/easing.mjs

@@ -0,0 +1,37 @@
+import { isBezierDefinition } from "../../../utils/is-bezier-definition.mjs";
+import { supportsLinearEasing } from "../../../utils/supports/linear-easing.mjs";
+import { generateLinearEasing } from "./linear.mjs";
+function isWaapiSupportedEasing(easing) {
+  return Boolean(typeof easing === "function" && supportsLinearEasing() || !easing || typeof easing === "string" && (easing in supportedWaapiEasing || supportsLinearEasing()) || isBezierDefinition(easing) || Array.isArray(easing) && easing.every(isWaapiSupportedEasing));
+}
+const cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;
+const supportedWaapiEasing = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ cubicBezierAsString([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ cubicBezierAsString([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ cubicBezierAsString([0.33, 1.53, 0.69, 0.99])
+};
+function mapEasingToNativeEasing(easing, duration) {
+  if (!easing) {
+    return void 0;
+  } else if (typeof easing === "function" && supportsLinearEasing()) {
+    return generateLinearEasing(easing, duration);
+  } else if (isBezierDefinition(easing)) {
+    return cubicBezierAsString(easing);
+  } else if (Array.isArray(easing)) {
+    return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) || supportedWaapiEasing.easeOut);
+  } else {
+    return supportedWaapiEasing[easing];
+  }
+}
+export {
+  cubicBezierAsString,
+  isWaapiSupportedEasing,
+  mapEasingToNativeEasing,
+  supportedWaapiEasing
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/utils/linear.mjs

@@ -0,0 +1,13 @@
+import "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { progress } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/progress.mjs";
+const generateLinearEasing = (easing, duration, resolution = 10) => {
+  let points = "";
+  const numPoints = Math.max(Math.round(duration / resolution), 2);
+  for (let i = 0; i < numPoints; i++) {
+    points += easing(progress(0, numPoints - 1, i)) + ", ";
+  }
+  return `linear(${points.substring(0, points.length - 2)})`;
+};
+export {
+  generateLinearEasing
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/batcher.mjs

@@ -0,0 +1,64 @@
+import "../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { stepsOrder } from "./order.mjs";
+import { createRenderStep } from "./render-step.mjs";
+const maxElapsed = 40;
+function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
+  let runNextFrame = false;
+  let useDefaultElapsed = true;
+  const state = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: false
+  };
+  const flagRunNextFrame = () => runNextFrame = true;
+  const steps = stepsOrder.reduce((acc, key) => {
+    acc[key] = createRenderStep(flagRunNextFrame, allowKeepAlive ? key : void 0);
+    return acc;
+  }, {});
+  const { read, resolveKeyframes, update, preRender, render, postRender } = steps;
+  const processBatch = () => {
+    const timestamp = performance.now();
+    runNextFrame = false;
+    {
+      state.delta = useDefaultElapsed ? 1e3 / 60 : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
+    }
+    state.timestamp = timestamp;
+    state.isProcessing = true;
+    read.process(state);
+    resolveKeyframes.process(state);
+    update.process(state);
+    preRender.process(state);
+    render.process(state);
+    postRender.process(state);
+    state.isProcessing = false;
+    if (runNextFrame && allowKeepAlive) {
+      useDefaultElapsed = false;
+      scheduleNextBatch(processBatch);
+    }
+  };
+  const wake = () => {
+    runNextFrame = true;
+    useDefaultElapsed = true;
+    if (!state.isProcessing) {
+      scheduleNextBatch(processBatch);
+    }
+  };
+  const schedule = stepsOrder.reduce((acc, key) => {
+    const step = steps[key];
+    acc[key] = (process, keepAlive = false, immediate = false) => {
+      if (!runNextFrame)
+        wake();
+      return step.schedule(process, keepAlive, immediate);
+    };
+    return acc;
+  }, {});
+  const cancel = (process) => {
+    for (let i = 0; i < stepsOrder.length; i++) {
+      steps[stepsOrder[i]].cancel(process);
+    }
+  };
+  return { schedule, cancel, state, steps };
+}
+export {
+  createRenderBatcher
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/frame.mjs

@@ -0,0 +1,10 @@
+import "../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { noop } from "../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/noop.mjs";
+import { createRenderBatcher } from "./batcher.mjs";
+const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop, true);
+export {
+  cancelFrame,
+  frame,
+  frameData,
+  frameSteps
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/microtask.mjs

@@ -0,0 +1,6 @@
+import { createRenderBatcher } from "./batcher.mjs";
+const { schedule: microtask, cancel: cancelMicrotask } = /* @__PURE__ */ createRenderBatcher(queueMicrotask, false);
+export {
+  cancelMicrotask,
+  microtask
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/order.mjs

@@ -0,0 +1,17 @@
+const stepsOrder = [
+  "read",
+  // Read
+  "resolveKeyframes",
+  // Write/Read/Write/Read
+  "update",
+  // Compute
+  "preRender",
+  // Compute
+  "render",
+  // Write
+  "postRender"
+  // Compute
+];
+export {
+  stepsOrder
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/render-step.mjs

@@ -0,0 +1,70 @@
+import { statsBuffer } from "../stats/buffer.mjs";
+function createRenderStep(runNextFrame, stepName) {
+  let thisFrame = /* @__PURE__ */ new Set();
+  let nextFrame = /* @__PURE__ */ new Set();
+  let isProcessing = false;
+  let flushNextFrame = false;
+  const toKeepAlive = /* @__PURE__ */ new WeakSet();
+  let latestFrameData = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: false
+  };
+  let numCalls = 0;
+  function triggerCallback(callback) {
+    if (toKeepAlive.has(callback)) {
+      step.schedule(callback);
+      runNextFrame();
+    }
+    numCalls++;
+    callback(latestFrameData);
+  }
+  const step = {
+    /**
+     * Schedule a process to run on the next frame.
+     */
+    schedule: (callback, keepAlive = false, immediate = false) => {
+      const addToCurrentFrame = immediate && isProcessing;
+      const queue = addToCurrentFrame ? thisFrame : nextFrame;
+      if (keepAlive)
+        toKeepAlive.add(callback);
+      if (!queue.has(callback))
+        queue.add(callback);
+      return callback;
+    },
+    /**
+     * Cancel the provided callback from running on the next frame.
+     */
+    cancel: (callback) => {
+      nextFrame.delete(callback);
+      toKeepAlive.delete(callback);
+    },
+    /**
+     * Execute all schedule callbacks.
+     */
+    process: (frameData) => {
+      latestFrameData = frameData;
+      if (isProcessing) {
+        flushNextFrame = true;
+        return;
+      }
+      isProcessing = true;
+      [thisFrame, nextFrame] = [nextFrame, thisFrame];
+      thisFrame.forEach(triggerCallback);
+      if (stepName && statsBuffer.value) {
+        statsBuffer.value.frameloop[stepName].push(numCalls);
+      }
+      numCalls = 0;
+      thisFrame.clear();
+      isProcessing = false;
+      if (flushNextFrame) {
+        flushNextFrame = false;
+        step.process(frameData);
+      }
+    }
+  };
+  return step;
+}
+export {
+  createRenderStep
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/sync-time.mjs

@@ -0,0 +1,22 @@
+import "../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { MotionGlobalConfig } from "../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/global-config.mjs";
+import { frameData } from "./frame.mjs";
+let now;
+function clearTime() {
+  now = void 0;
+}
+const time = {
+  now: () => {
+    if (now === void 0) {
+      time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now());
+    }
+    return now;
+  },
+  set: (newTime) => {
+    now = newTime;
+    queueMicrotask(clearTime);
+  }
+};
+export {
+  time
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/drag/state/is-active.mjs

@@ -0,0 +1,11 @@
+const isDragging = {
+  x: false,
+  y: false
+};
+function isDragActive() {
+  return isDragging.y;
+}
+export {
+  isDragActive,
+  isDragging
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/hover.mjs

@@ -0,0 +1,30 @@
+import { isDragActive } from "./drag/state/is-active.mjs";
+import { setupGesture } from "./utils/setup.mjs";
+function isValidHover(event) {
+  return !(event.pointerType === "touch" || isDragActive());
+}
+function hover(elementOrSelector, onHoverStart, options = {}) {
+  const [elements, eventOptions, cancel] = setupGesture(elementOrSelector, options);
+  const onPointerEnter = (enterEvent) => {
+    if (!isValidHover(enterEvent))
+      return;
+    const { target } = enterEvent;
+    const onHoverEnd = onHoverStart(target, enterEvent);
+    if (typeof onHoverEnd !== "function" || !target)
+      return;
+    const onPointerLeave = (leaveEvent) => {
+      if (!isValidHover(leaveEvent))
+        return;
+      onHoverEnd(leaveEvent);
+      target.removeEventListener("pointerleave", onPointerLeave);
+    };
+    target.addEventListener("pointerleave", onPointerLeave, eventOptions);
+  };
+  elements.forEach((element) => {
+    element.addEventListener("pointerenter", onPointerEnter, eventOptions);
+  });
+  return cancel;
+}
+export {
+  hover
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/press/index.mjs

@@ -0,0 +1,74 @@
+import { isDragActive } from "../drag/state/is-active.mjs";
+import { capturePointer } from "../utils/capture-pointer.mjs";
+import { isNodeOrChild } from "../utils/is-node-or-child.mjs";
+import { isPrimaryPointer } from "../utils/is-primary-pointer.mjs";
+import { setupGesture } from "../utils/setup.mjs";
+import { isElementKeyboardAccessible } from "./utils/is-keyboard-accessible.mjs";
+import { enableKeyboardPress } from "./utils/keyboard.mjs";
+import { isPressing } from "./utils/state.mjs";
+function isValidPressEvent(event) {
+  return isPrimaryPointer(event) && !isDragActive();
+}
+function press(targetOrSelector, onPressStart, options = {}) {
+  const [targets, eventOptions, cancelEvents] = setupGesture(targetOrSelector, options);
+  const startPress = (startEvent) => {
+    const target = startEvent.currentTarget;
+    if (!target || !isValidPressEvent(startEvent) || isPressing.has(target))
+      return;
+    isPressing.add(target);
+    capturePointer(startEvent, "set");
+    const onPressEnd = onPressStart(target, startEvent);
+    const onPointerEnd = (endEvent, success) => {
+      target.removeEventListener("pointerup", onPointerUp);
+      target.removeEventListener("pointercancel", onPointerCancel);
+      capturePointer(endEvent, "release");
+      if (!isValidPressEvent(endEvent) || !isPressing.has(target)) {
+        return;
+      }
+      isPressing.delete(target);
+      if (typeof onPressEnd === "function") {
+        onPressEnd(endEvent, { success });
+      }
+    };
+    const onPointerUp = (upEvent) => {
+      const isOutside = !upEvent.isTrusted ? false : checkOutside(upEvent, target instanceof Element ? target.getBoundingClientRect() : {
+        left: 0,
+        top: 0,
+        right: window.innerWidth,
+        bottom: window.innerHeight
+      });
+      if (isOutside) {
+        onPointerEnd(upEvent, false);
+      } else {
+        onPointerEnd(upEvent, !(target instanceof Element) || isNodeOrChild(target, upEvent.target));
+      }
+    };
+    const onPointerCancel = (cancelEvent) => {
+      onPointerEnd(cancelEvent, false);
+    };
+    target.addEventListener("pointerup", onPointerUp, eventOptions);
+    target.addEventListener("pointercancel", onPointerCancel, eventOptions);
+    target.addEventListener("lostpointercapture", onPointerCancel, eventOptions);
+  };
+  targets.forEach((target) => {
+    target = options.useGlobalTarget ? window : target;
+    let canAddKeyboardAccessibility = false;
+    if (target instanceof HTMLElement) {
+      canAddKeyboardAccessibility = true;
+      if (!isElementKeyboardAccessible(target) && target.getAttribute("tabindex") === null) {
+        target.tabIndex = 0;
+      }
+    }
+    target.addEventListener("pointerdown", startPress, eventOptions);
+    if (canAddKeyboardAccessibility) {
+      target.addEventListener("focus", (event) => enableKeyboardPress(event, eventOptions), eventOptions);
+    }
+  });
+  return cancelEvents;
+}
+function checkOutside(event, rect) {
+  return event.clientX < rect.left || event.clientX > rect.right || event.clientY < rect.top || event.clientY > rect.bottom;
+}
+export {
+  press
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.mjs

@@ -0,0 +1,13 @@
+const focusableElements = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function isElementKeyboardAccessible(element) {
+  return focusableElements.has(element.tagName) || element.tabIndex !== -1;
+}
+export {
+  isElementKeyboardAccessible
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/press/utils/keyboard.mjs

@@ -0,0 +1,32 @@
+import { isPressing } from "./state.mjs";
+function filterEvents(callback) {
+  return (event) => {
+    if (event.key !== "Enter")
+      return;
+    callback(event);
+  };
+}
+function firePointerEvent(target, type) {
+  target.dispatchEvent(new PointerEvent("pointer" + type, { isPrimary: true, bubbles: true }));
+}
+const enableKeyboardPress = (focusEvent, eventOptions) => {
+  const element = focusEvent.currentTarget;
+  if (!element)
+    return;
+  const handleKeydown = filterEvents(() => {
+    if (isPressing.has(element))
+      return;
+    firePointerEvent(element, "down");
+    const handleKeyup = filterEvents(() => {
+      firePointerEvent(element, "up");
+    });
+    const handleBlur = () => firePointerEvent(element, "cancel");
+    element.addEventListener("keyup", handleKeyup, eventOptions);
+    element.addEventListener("blur", handleBlur, eventOptions);
+  });
+  element.addEventListener("keydown", handleKeydown, eventOptions);
+  element.addEventListener("blur", () => element.removeEventListener("keydown", handleKeydown), eventOptions);
+};
+export {
+  enableKeyboardPress
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/press/utils/state.mjs

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

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/utils/capture-pointer.mjs

@@ -0,0 +1,12 @@
+function capturePointer(event, action) {
+  const actionName = `${action}PointerCapture`;
+  if (event.target instanceof Element && actionName in event.target && event.pointerId !== void 0) {
+    try {
+      event.target[actionName](event.pointerId);
+    } catch (e) {
+    }
+  }
+}
+export {
+  capturePointer
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/utils/is-node-or-child.mjs

@@ -0,0 +1,12 @@
+const isNodeOrChild = (parent, child) => {
+  if (!child) {
+    return false;
+  } else if (parent === child) {
+    return true;
+  } else {
+    return isNodeOrChild(parent, child.parentElement);
+  }
+};
+export {
+  isNodeOrChild
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs

@@ -0,0 +1,10 @@
+const isPrimaryPointer = (event) => {
+  if (event.pointerType === "mouse") {
+    return typeof event.button !== "number" || event.button <= 0;
+  } else {
+    return event.isPrimary !== false;
+  }
+};
+export {
+  isPrimaryPointer
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/gestures/utils/setup.mjs

@@ -0,0 +1,15 @@
+import { resolveElements } from "../../utils/resolve-elements.mjs";
+function setupGesture(elementOrSelector, options) {
+  const elements = resolveElements(elementOrSelector);
+  const gestureAbortController = new AbortController();
+  const eventOptions = {
+    passive: true,
+    ...options,
+    signal: gestureAbortController.signal
+  };
+  const cancel = () => gestureAbortController.abort();
+  return [elements, eventOptions, cancel];
+}
+export {
+  setupGesture
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/stats/buffer.mjs

@@ -0,0 +1,7 @@
+const statsBuffer = {
+  value: null,
+  addProjectionMetrics: null
+};
+export {
+  statsBuffer
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/utils/is-bezier-definition.mjs

@@ -0,0 +1,4 @@
+const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === "number";
+export {
+  isBezierDefinition
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/utils/resolve-elements.mjs

@@ -0,0 +1,17 @@
+function resolveElements(elementOrSelector, scope, selectorCache) {
+  var _a;
+  if (elementOrSelector instanceof EventTarget) {
+    return [elementOrSelector];
+  } else if (typeof elementOrSelector === "string") {
+    let root = document;
+    if (scope) {
+      root = scope.current;
+    }
+    const elements = (_a = selectorCache === null || selectorCache === void 0 ? void 0 : selectorCache[elementOrSelector]) !== null && _a !== void 0 ? _a : root.querySelectorAll(elementOrSelector);
+    return elements ? Array.from(elements) : [];
+  }
+  return Array.from(elementOrSelector);
+}
+export {
+  resolveElements
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/utils/supports/flags.mjs

@@ -0,0 +1,6 @@
+const supportsFlags = {
+  linearEasing: void 0
+};
+export {
+  supportsFlags
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/utils/supports/linear-easing.mjs

@@ -0,0 +1,12 @@
+import { memoSupports } from "./memo.mjs";
+const supportsLinearEasing = /* @__PURE__ */ memoSupports(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch (e) {
+    return false;
+  }
+  return true;
+}, "linearEasing");
+export {
+  supportsLinearEasing
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/utils/supports/memo.mjs

@@ -0,0 +1,13 @@
+import "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { memo } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/memo.mjs";
+import { supportsFlags } from "./flags.mjs";
+function memoSupports(callback, supportsFlag) {
+  const memoized = memo(callback);
+  return () => {
+    var _a;
+    return (_a = supportsFlags[supportsFlag]) !== null && _a !== void 0 ? _a : memoized();
+  };
+}
+export {
+  memoSupports
+};

package/dist/es/external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/utils/supports/scroll-timeline.mjs

@@ -0,0 +1,6 @@
+import "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { memo } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/memo.mjs";
+const supportsScrollTimeline = /* @__PURE__ */ memo(() => window.ScrollTimeline !== void 0);
+export {
+  supportsScrollTimeline
+};