@qredence/fleet 0.6.0 → 0.6.2

package/dist/web/server/chunk-7E76R7MB.js

@@ -0,0 +1,2138 @@
+// web/app/dist/server/assets/is-ref-object-BOCcojEl.js
+import { createContext, useRef } from "react";
+var LayoutGroupContext = createContext({});
+function useConstant(init) {
+  const ref = useRef(null);
+  if (ref.current === null) ref.current = init();
+  return ref.current;
+}
+var PresenceContext = /* @__PURE__ */ createContext(null);
+function addUniqueItem(arr, item) {
+  if (arr.indexOf(item) === -1) arr.push(item);
+}
+function removeItem(arr, item) {
+  const index = arr.indexOf(item);
+  if (index > -1) arr.splice(index, 1);
+}
+var clamp = (min, max, v) => {
+  if (v > max) return max;
+  if (v < min) return min;
+  return v;
+};
+var warning = () => {
+};
+var invariant = () => {
+};
+var MotionGlobalConfig = {};
+var isNumericalString = (v) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(v);
+var isZeroValueString = (v) => /^0[^.\s]+$/u.test(v);
+// @__NO_SIDE_EFFECTS__
+function memo$1(callback) {
+  let result;
+  return () => {
+    if (result === void 0) result = callback();
+    return result;
+  };
+}
+var noop = /* @__NO_SIDE_EFFECTS__ */ (any) => any;
+var SubscriptionManager = class {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(handler) {
+    addUniqueItem(this.subscriptions, handler);
+    return () => removeItem(this.subscriptions, handler);
+  }
+  notify(a, b, c) {
+    const numSubscriptions = this.subscriptions.length;
+    if (!numSubscriptions) return;
+    if (numSubscriptions === 1)
+      this.subscriptions[0](a, b, c);
+    else for (let i = 0; i < numSubscriptions; i++) {
+      const handler = this.subscriptions[i];
+      handler && handler(a, b, c);
+    }
+  }
+  getSize() {
+    return this.subscriptions.length;
+  }
+  clear() {
+    this.subscriptions.length = 0;
+  }
+};
+var secondsToMilliseconds = /* @__NO_SIDE_EFFECTS__ */ (seconds) => seconds * 1e3;
+var millisecondsToSeconds = /* @__NO_SIDE_EFFECTS__ */ (milliseconds) => milliseconds / 1e3;
+var velocityPerSecond = /* @__NO_SIDE_EFFECTS__ */ (velocity, frameDuration) => frameDuration ? velocity * (1e3 / frameDuration) : 0;
+var isBezierDefinition = /* @__NO_SIDE_EFFECTS__ */ (easing) => Array.isArray(easing) && typeof easing[0] === "number";
+var stepsOrder = [
+  "setup",
+  "read",
+  "resolveKeyframes",
+  "preUpdate",
+  "update",
+  "preRender",
+  "render",
+  "postRender"
+];
+function createRenderStep(runNextFrame) {
+  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
+  };
+  function triggerCallback(callback) {
+    if (toKeepAlive.has(callback)) {
+      step.schedule(callback);
+      runNextFrame();
+    }
+    callback(latestFrameData);
+  }
+  const step = {
+    /**
+    * Schedule a process to run on the next frame.
+    */
+    schedule: (callback, keepAlive = false, immediate = false) => {
+      const queue = immediate && isProcessing ? thisFrame : nextFrame;
+      if (keepAlive) toKeepAlive.add(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: (frameData2) => {
+      latestFrameData = frameData2;
+      if (isProcessing) {
+        flushNextFrame = true;
+        return;
+      }
+      isProcessing = true;
+      const prevFrame = thisFrame;
+      thisFrame = nextFrame;
+      nextFrame = prevFrame;
+      thisFrame.forEach(triggerCallback);
+      thisFrame.clear();
+      isProcessing = false;
+      if (flushNextFrame) {
+        flushNextFrame = false;
+        step.process(frameData2);
+      }
+    }
+  };
+  return step;
+}
+var 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);
+    return acc;
+  }, {});
+  const { setup, read, resolveKeyframes, preUpdate, update, preRender, render, postRender } = steps;
+  const processBatch = () => {
+    const useManualTiming = MotionGlobalConfig.useManualTiming;
+    const timestamp = useManualTiming ? state.timestamp : performance.now();
+    runNextFrame = false;
+    if (!useManualTiming) state.delta = useDefaultElapsed ? 1e3 / 60 : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
+    state.timestamp = timestamp;
+    state.isProcessing = true;
+    setup.process(state);
+    read.process(state);
+    resolveKeyframes.process(state);
+    preUpdate.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
+  };
+}
+var { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop, true);
+var now;
+function clearTime() {
+  now = void 0;
+}
+var time = {
+  now: () => {
+    if (now === void 0) time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now());
+    return now;
+  },
+  set: (newTime) => {
+    now = newTime;
+    queueMicrotask(clearTime);
+  }
+};
+var checkStringStartsWith = (token) => (key) => typeof key === "string" && key.startsWith(token);
+var isCSSVariableName = /* @__PURE__ */ checkStringStartsWith("--");
+var startsAsVariableToken = /* @__PURE__ */ checkStringStartsWith("var(--");
+var isCSSVariableToken = (value) => {
+  if (!startsAsVariableToken(value)) return false;
+  return singleCssVariableRegex.test(value.split("/*")[0].trim());
+};
+var singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+function containsCSSVariable(value) {
+  if (typeof value !== "string") return false;
+  return value.split("/*")[0].includes("var(--");
+}
+var number = {
+  test: (v) => typeof v === "number",
+  parse: parseFloat,
+  transform: (v) => v
+};
+var alpha = {
+  ...number,
+  transform: (v) => clamp(0, 1, v)
+};
+var scale = {
+  ...number,
+  default: 1
+};
+var sanitize = (v) => Math.round(v * 1e5) / 1e5;
+var floatRegex = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
+function isNullish(v) {
+  return v == null;
+}
+var singleColorRegex = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu;
+var isColorString = (type, testProp) => (v) => {
+  return Boolean(typeof v === "string" && singleColorRegex.test(v) && v.startsWith(type) || testProp && !isNullish(v) && Object.prototype.hasOwnProperty.call(v, testProp));
+};
+var splitColor = (aName, bName, cName) => (v) => {
+  if (typeof v !== "string") return v;
+  const [a, b, c, alpha2] = v.match(floatRegex);
+  return {
+    [aName]: parseFloat(a),
+    [bName]: parseFloat(b),
+    [cName]: parseFloat(c),
+    alpha: alpha2 !== void 0 ? parseFloat(alpha2) : 1
+  };
+};
+var clampRgbUnit = (v) => clamp(0, 255, v);
+var rgbUnit = {
+  ...number,
+  transform: (v) => Math.round(clampRgbUnit(v))
+};
+var rgba = {
+  test: /* @__PURE__ */ isColorString("rgb", "red"),
+  parse: /* @__PURE__ */ splitColor("red", "green", "blue"),
+  transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => "rgba(" + rgbUnit.transform(red) + ", " + rgbUnit.transform(green) + ", " + rgbUnit.transform(blue) + ", " + sanitize(alpha.transform(alpha$1)) + ")"
+};
+function parseHex(v) {
+  let r = "";
+  let g = "";
+  let b = "";
+  let a = "";
+  if (v.length > 5) {
+    r = v.substring(1, 3);
+    g = v.substring(3, 5);
+    b = v.substring(5, 7);
+    a = v.substring(7, 9);
+  } else {
+    r = v.substring(1, 2);
+    g = v.substring(2, 3);
+    b = v.substring(3, 4);
+    a = v.substring(4, 5);
+    r += r;
+    g += g;
+    b += b;
+    a += a;
+  }
+  return {
+    red: parseInt(r, 16),
+    green: parseInt(g, 16),
+    blue: parseInt(b, 16),
+    alpha: a ? parseInt(a, 16) / 255 : 1
+  };
+}
+var hex = {
+  test: /* @__PURE__ */ isColorString("#"),
+  parse: parseHex,
+  transform: rgba.transform
+};
+var createUnitType = /* @__NO_SIDE_EFFECTS__ */ (unit) => ({
+  test: (v) => typeof v === "string" && v.endsWith(unit) && v.split(" ").length === 1,
+  parse: parseFloat,
+  transform: (v) => `${v}${unit}`
+});
+var degrees = /* @__PURE__ */ createUnitType("deg");
+var percent = /* @__PURE__ */ createUnitType("%");
+var px = /* @__PURE__ */ createUnitType("px");
+var vh = /* @__PURE__ */ createUnitType("vh");
+var vw = /* @__PURE__ */ createUnitType("vw");
+var progressPercentage = /* @__PURE__ */ (() => ({
+  ...percent,
+  parse: (v) => percent.parse(v) / 100,
+  transform: (v) => percent.transform(v * 100)
+}))();
+var hsla = {
+  test: /* @__PURE__ */ isColorString("hsl", "hue"),
+  parse: /* @__PURE__ */ splitColor("hue", "saturation", "lightness"),
+  transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {
+    return "hsla(" + Math.round(hue) + ", " + percent.transform(sanitize(saturation)) + ", " + percent.transform(sanitize(lightness)) + ", " + sanitize(alpha.transform(alpha$1)) + ")";
+  }
+};
+var color = {
+  test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),
+  parse: (v) => {
+    if (rgba.test(v)) return rgba.parse(v);
+    else if (hsla.test(v)) return hsla.parse(v);
+    else return hex.parse(v);
+  },
+  transform: (v) => {
+    return typeof v === "string" ? v : v.hasOwnProperty("red") ? rgba.transform(v) : hsla.transform(v);
+  },
+  getAnimatableNone: (v) => {
+    const parsed = color.parse(v);
+    parsed.alpha = 0;
+    return color.transform(parsed);
+  }
+};
+var colorRegex = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
+function test(v) {
+  return isNaN(v) && typeof v === "string" && (v.match(floatRegex)?.length || 0) + (v.match(colorRegex)?.length || 0) > 0;
+}
+var NUMBER_TOKEN = "number";
+var COLOR_TOKEN = "color";
+var VAR_TOKEN = "var";
+var VAR_FUNCTION_TOKEN = "var(";
+var SPLIT_TOKEN = "${}";
+var complexRegex = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function analyseComplexValue(value) {
+  const originalValue = value.toString();
+  const values = [];
+  const indexes = {
+    color: [],
+    number: [],
+    var: []
+  };
+  const types = [];
+  let i = 0;
+  return {
+    values,
+    split: originalValue.replace(complexRegex, (parsedValue) => {
+      if (color.test(parsedValue)) {
+        indexes.color.push(i);
+        types.push(COLOR_TOKEN);
+        values.push(color.parse(parsedValue));
+      } else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {
+        indexes.var.push(i);
+        types.push(VAR_TOKEN);
+        values.push(parsedValue);
+      } else {
+        indexes.number.push(i);
+        types.push(NUMBER_TOKEN);
+        values.push(parseFloat(parsedValue));
+      }
+      ++i;
+      return SPLIT_TOKEN;
+    }).split(SPLIT_TOKEN),
+    indexes,
+    types
+  };
+}
+function parseComplexValue(v) {
+  return analyseComplexValue(v).values;
+}
+function buildTransformer({ split, types }) {
+  const numSections = split.length;
+  return (v) => {
+    let output = "";
+    for (let i = 0; i < numSections; i++) {
+      output += split[i];
+      if (v[i] !== void 0) {
+        const type = types[i];
+        if (type === NUMBER_TOKEN) output += sanitize(v[i]);
+        else if (type === COLOR_TOKEN) output += color.transform(v[i]);
+        else output += v[i];
+      }
+    }
+    return output;
+  };
+}
+function createTransformer(source) {
+  return buildTransformer(analyseComplexValue(source));
+}
+var convertNumbersToZero = (v) => typeof v === "number" ? 0 : color.test(v) ? color.getAnimatableNone(v) : v;
+var convertToZero = (value, splitBefore) => {
+  if (typeof value === "number") return splitBefore?.trim().endsWith("/") ? value : 0;
+  return convertNumbersToZero(value);
+};
+function getAnimatableNone$1(v) {
+  const info = analyseComplexValue(v);
+  return buildTransformer(info)(info.values.map((value, i) => convertToZero(value, info.split[i])));
+}
+var complex = {
+  test,
+  parse: parseComplexValue,
+  createTransformer,
+  getAnimatableNone: getAnimatableNone$1
+};
+var mixNumber = (from, to, progress) => {
+  return from + (to - from) * progress;
+};
+var generateLinearEasing = (easing, duration, resolution = 10) => {
+  let points = "";
+  const numPoints = Math.max(Math.round(duration / resolution), 2);
+  for (let i = 0; i < numPoints; i++) points += Math.round(easing(i / (numPoints - 1)) * 1e4) / 1e4 + ", ";
+  return `linear(${points.substring(0, points.length - 2)})`;
+};
+var isNotNull = (value) => value !== null;
+function getFinalKeyframe(keyframes, { repeat, repeatType = "loop" }, finalKeyframe, speed = 1) {
+  const resolvedKeyframes = keyframes.filter(isNotNull);
+  const index = speed < 0 || repeat && repeatType !== "loop" && repeat % 2 === 1 ? 0 : resolvedKeyframes.length - 1;
+  return !index || finalKeyframe === void 0 ? resolvedKeyframes[index] : finalKeyframe;
+}
+var WithPromise = class {
+  constructor() {
+    this.updateFinished();
+  }
+  get finished() {
+    return this._finished;
+  }
+  updateFinished() {
+    this._finished = new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+  notifyFinished() {
+    this.resolve();
+  }
+  /**
+  * Allows the animation to be awaited.
+  *
+  * @deprecated Use `finished` instead.
+  */
+  then(onResolve, onReject) {
+    return this.finished.then(onResolve, onReject);
+  }
+};
+function fillWildcards(keyframes) {
+  for (let i = 1; i < keyframes.length; i++) keyframes[i] ?? (keyframes[i] = keyframes[i - 1]);
+}
+var radToDeg = (rad) => rad * 180 / Math.PI;
+var rotate = (v) => {
+  return rebaseAngle(radToDeg(Math.atan2(v[1], v[0])));
+};
+var matrix2dParsers = {
+  x: 4,
+  y: 5,
+  translateX: 4,
+  translateY: 5,
+  scaleX: 0,
+  scaleY: 3,
+  scale: (v) => (Math.abs(v[0]) + Math.abs(v[3])) / 2,
+  rotate,
+  rotateZ: rotate,
+  skewX: (v) => radToDeg(Math.atan(v[1])),
+  skewY: (v) => radToDeg(Math.atan(v[2])),
+  skew: (v) => (Math.abs(v[1]) + Math.abs(v[2])) / 2
+};
+var rebaseAngle = (angle) => {
+  angle = angle % 360;
+  if (angle < 0) angle += 360;
+  return angle;
+};
+var rotateZ = rotate;
+var scaleX = (v) => Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+var scaleY = (v) => Math.sqrt(v[4] * v[4] + v[5] * v[5]);
+var matrix3dParsers = {
+  x: 12,
+  y: 13,
+  z: 14,
+  translateX: 12,
+  translateY: 13,
+  translateZ: 14,
+  scaleX,
+  scaleY,
+  scale: (v) => (scaleX(v) + scaleY(v)) / 2,
+  rotateX: (v) => rebaseAngle(radToDeg(Math.atan2(v[6], v[5]))),
+  rotateY: (v) => rebaseAngle(radToDeg(Math.atan2(-v[2], v[0]))),
+  rotateZ,
+  rotate: rotateZ,
+  skewX: (v) => radToDeg(Math.atan(v[4])),
+  skewY: (v) => radToDeg(Math.atan(v[1])),
+  skew: (v) => (Math.abs(v[1]) + Math.abs(v[4])) / 2
+};
+function defaultTransformValue(name) {
+  return name.includes("scale") ? 1 : 0;
+}
+function parseValueFromTransform(transform, name) {
+  if (!transform || transform === "none") return defaultTransformValue(name);
+  const matrix3dMatch = transform.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
+  let parsers;
+  let match;
+  if (matrix3dMatch) {
+    parsers = matrix3dParsers;
+    match = matrix3dMatch;
+  } else {
+    const matrix2dMatch = transform.match(/^matrix\(([-\d.e\s,]+)\)$/u);
+    parsers = matrix2dParsers;
+    match = matrix2dMatch;
+  }
+  if (!match) return defaultTransformValue(name);
+  const valueParser = parsers[name];
+  const values = match[1].split(",").map(convertTransformToNumber);
+  return typeof valueParser === "function" ? valueParser(values) : values[valueParser];
+}
+var readTransformValue = (instance, name) => {
+  const { transform = "none" } = getComputedStyle(instance);
+  return parseValueFromTransform(transform, name);
+};
+function convertTransformToNumber(value) {
+  return parseFloat(value.trim());
+}
+var transformPropOrder = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+];
+var transformProps = /* @__PURE__ */ (() => /* @__PURE__ */ new Set([...transformPropOrder, "pathRotation"]))();
+var isNumOrPxType = (v) => v === number || v === px;
+var transformKeys = /* @__PURE__ */ new Set([
+  "x",
+  "y",
+  "z"
+]);
+var 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;
+}
+var positionalValues = {
+  width: ({ x }, { paddingLeft = "0", paddingRight = "0", boxSizing }) => {
+    const width = x.max - x.min;
+    return boxSizing === "border-box" ? width : width - parseFloat(paddingLeft) - parseFloat(paddingRight);
+  },
+  height: ({ y }, { paddingTop = "0", paddingBottom = "0", boxSizing }) => {
+    const height = y.max - y.min;
+    return boxSizing === "border-box" ? height : height - 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),
+  x: (_bbox, { transform }) => parseValueFromTransform(transform, "x"),
+  y: (_bbox, { transform }) => parseValueFromTransform(transform, "y")
+};
+positionalValues.translateX = positionalValues.x;
+positionalValues.translateY = positionalValues.y;
+var toResolve = /* @__PURE__ */ new Set();
+var isScheduled = false;
+var anyNeedsMeasurement = false;
+var isForced = 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]) => {
+        element.getValue(key)?.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(isForced));
+  toResolve.clear();
+}
+function readAllKeyframes() {
+  toResolve.forEach((resolver) => {
+    resolver.readKeyframes();
+    if (resolver.needsMeasurement) anyNeedsMeasurement = true;
+  });
+}
+function flushKeyframeResolvers() {
+  isForced = true;
+  readAllKeyframes();
+  measureAllKeyframes();
+  isForced = false;
+}
+var KeyframeResolver = class {
+  constructor(unresolvedKeyframes, onComplete, name, motionValue2, element, isAsync = false) {
+    this.state = "pending";
+    this.isAsync = false;
+    this.needsMeasurement = false;
+    this.unresolvedKeyframes = [...unresolvedKeyframes];
+    this.onComplete = onComplete;
+    this.name = name;
+    this.motionValue = motionValue2;
+    this.element = element;
+    this.isAsync = isAsync;
+  }
+  scheduleResolve() {
+    this.state = "scheduled";
+    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: motionValue2 } = this;
+    if (unresolvedKeyframes[0] === null) {
+      const currentValue = motionValue2?.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 (motionValue2 && currentValue === void 0) motionValue2.set(unresolvedKeyframes[0]);
+    }
+    fillWildcards(unresolvedKeyframes);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(isForcedComplete = false) {
+    this.state = "complete";
+    this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, isForcedComplete);
+    toResolve.delete(this);
+  }
+  cancel() {
+    if (this.state === "scheduled") {
+      toResolve.delete(this);
+      this.state = "pending";
+    }
+  }
+  resume() {
+    if (this.state === "pending") this.scheduleResolve();
+  }
+};
+var isCSSVar = (name) => name.startsWith("--");
+function setStyle(element, name, value) {
+  isCSSVar(name) ? element.style.setProperty(name, value) : element.style[name] = value;
+}
+var supportsFlags = {};
+function memoSupports(callback, supportsFlag) {
+  const memoized = /* @__PURE__ */ memo$1(callback);
+  return () => supportsFlags[supportsFlag] ?? memoized();
+}
+var supportsScrollTimeline = /* @__PURE__ */ memoSupports(() => window.ScrollTimeline !== void 0, "scrollTimeline");
+var supportsLinearEasing = /* @__PURE__ */ memoSupports(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch (e) {
+    return false;
+  }
+  return true;
+}, "linearEasing");
+var cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;
+var 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;
+  else if (typeof easing === "function") return supportsLinearEasing() ? generateLinearEasing(easing, duration) : "ease-out";
+  else if (/* @__PURE__ */ isBezierDefinition(easing)) return cubicBezierAsString(easing);
+  else if (Array.isArray(easing)) return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) || supportedWaapiEasing.easeOut);
+  else return supportedWaapiEasing[easing];
+}
+function startWaapiAnimation(element, valueName, keyframes, { delay = 0, duration = 300, repeat = 0, repeatType = "loop", ease = "easeOut", times } = {}, pseudoElement = void 0) {
+  const keyframeOptions = { [valueName]: keyframes };
+  if (times) keyframeOptions.offset = times;
+  const easing = mapEasingToNativeEasing(ease, duration);
+  if (Array.isArray(easing)) keyframeOptions.easing = easing;
+  const options = {
+    delay,
+    duration,
+    easing: !Array.isArray(easing) ? easing : "linear",
+    fill: "both",
+    iterations: repeat + 1,
+    direction: repeatType === "reverse" ? "alternate" : "normal"
+  };
+  if (pseudoElement) options.pseudoElement = pseudoElement;
+  return element.animate(keyframeOptions, options);
+}
+function isGenerator(type) {
+  return typeof type === "function" && "applyToOptions" in type;
+}
+function applyGeneratorOptions({ type, ...options }) {
+  if (isGenerator(type) && supportsLinearEasing()) return type.applyToOptions(options);
+  else {
+    options.duration ?? (options.duration = 300);
+    options.ease ?? (options.ease = "easeOut");
+  }
+  return options;
+}
+var NativeAnimation = class extends WithPromise {
+  constructor(options) {
+    super();
+    this.finishedTime = null;
+    this.isStopped = false;
+    this.manualStartTime = null;
+    if (!options) return;
+    const { element, name, keyframes, pseudoElement, allowFlatten = false, finalKeyframe, onComplete } = options;
+    this.isPseudoElement = Boolean(pseudoElement);
+    this.allowFlatten = allowFlatten;
+    this.options = options;
+    options.type;
+    const transition = applyGeneratorOptions(options);
+    this.animation = startWaapiAnimation(element, name, keyframes, transition, pseudoElement);
+    if (transition.autoplay === false) this.animation.pause();
+    this.animation.onfinish = () => {
+      this.finishedTime = this.time;
+      if (!pseudoElement) {
+        const keyframe = getFinalKeyframe(keyframes, this.options, finalKeyframe, this.speed);
+        if (this.updateMotionValue) this.updateMotionValue(keyframe);
+        setStyle(element, name, keyframe);
+        this.animation.cancel();
+      }
+      onComplete?.();
+      this.notifyFinished();
+    };
+  }
+  play() {
+    if (this.isStopped) return;
+    this.manualStartTime = null;
+    this.animation.play();
+    if (this.state === "finished") this.updateFinished();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.finish?.();
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch (e) {
+    }
+  }
+  stop() {
+    if (this.isStopped) return;
+    this.isStopped = true;
+    const { state } = this;
+    if (state === "idle" || state === "finished") return;
+    if (this.updateMotionValue) this.updateMotionValue();
+    else this.commitStyles();
+    if (!this.isPseudoElement) this.cancel();
+  }
+  /**
+  * WAAPI doesn't natively have any interruption capabilities.
+  *
+  * In this method, we commit styles back to the DOM before cancelling
+  * the animation.
+  *
+  * This is designed to be overridden by NativeAnimationExtended, which
+  * will create a renderless JS animation and sample it twice to calculate
+  * its current value, "previous" value, and therefore allow
+  * Motion to also correctly calculate velocity for any subsequent animation
+  * while deferring the commit until the next animation frame.
+  */
+  commitStyles() {
+    const element = this.options?.element;
+    if (!this.isPseudoElement && element?.isConnected) this.animation.commitStyles?.();
+  }
+  get duration() {
+    const duration = this.animation.effect?.getComputedTiming?.().duration || 0;
+    return /* @__PURE__ */ millisecondsToSeconds(Number(duration));
+  }
+  get iterationDuration() {
+    const { delay = 0 } = this.options || {};
+    return this.duration + /* @__PURE__ */ millisecondsToSeconds(delay);
+  }
+  get time() {
+    return /* @__PURE__ */ millisecondsToSeconds(Number(this.animation.currentTime) || 0);
+  }
+  set time(newTime) {
+    const wasFinished = this.finishedTime !== null;
+    this.manualStartTime = null;
+    this.finishedTime = null;
+    this.animation.currentTime = /* @__PURE__ */ secondsToMilliseconds(newTime);
+    if (wasFinished) this.animation.pause();
+  }
+  /**
+  * The playback speed of the animation.
+  * 1 = normal speed, 2 = double speed, 0.5 = half speed.
+  */
+  get speed() {
+    return this.animation.playbackRate;
+  }
+  set speed(newSpeed) {
+    if (newSpeed < 0) this.finishedTime = null;
+    this.animation.playbackRate = newSpeed;
+  }
+  get state() {
+    return this.finishedTime !== null ? "finished" : this.animation.playState;
+  }
+  get startTime() {
+    return this.manualStartTime ?? Number(this.animation.startTime);
+  }
+  set startTime(newStartTime) {
+    this.manualStartTime = this.animation.startTime = newStartTime;
+  }
+  /**
+  * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+  */
+  attachTimeline({ timeline, rangeStart, rangeEnd, observe }) {
+    if (this.allowFlatten) this.animation.effect?.updateTiming({ easing: "linear" });
+    this.animation.onfinish = null;
+    if (timeline && supportsScrollTimeline()) {
+      this.animation.timeline = timeline;
+      if (rangeStart) this.animation.rangeStart = rangeStart;
+      if (rangeEnd) this.animation.rangeEnd = rangeEnd;
+      return noop;
+    } else return observe(this);
+  }
+};
+var acceleratedValues = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform",
+  "backgroundColor"
+]);
+var MAX_VELOCITY_DELTA = 30;
+var isFloat = (value) => {
+  return !isNaN(parseFloat(value));
+};
+var collectMotionValues = { current: void 0 };
+var MotionValue = class {
+  /**
+  * @param init - The initiating value
+  * @param config - Optional configuration options
+  *
+  * -  `transformer`: A function to transform incoming values with.
+  */
+  constructor(init, options = {}) {
+    this.canTrackVelocity = null;
+    this.events = {};
+    this.updateAndNotify = (v) => {
+      const currentTime = time.now();
+      if (this.updatedAt !== currentTime) this.setPrevFrameValue();
+      this.prev = this.current;
+      this.setCurrent(v);
+      if (this.current !== this.prev) {
+        this.events.change?.notify(this.current);
+        if (this.dependents) for (const dependent of this.dependents) dependent.dirty();
+      }
+    };
+    this.hasAnimated = false;
+    this.setCurrent(init);
+    this.owner = options.owner;
+  }
+  setCurrent(current) {
+    this.current = current;
+    this.updatedAt = time.now();
+    if (this.canTrackVelocity === null && current !== void 0) this.canTrackVelocity = isFloat(this.current);
+  }
+  setPrevFrameValue(prevFrameValue = this.current) {
+    this.prevFrameValue = prevFrameValue;
+    this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+  * Adds a function that will be notified when the `MotionValue` is updated.
+  *
+  * It returns a function that, when called, will cancel the subscription.
+  *
+  * When calling `onChange` inside a React component, it should be wrapped with the
+  * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+  * from the `useEffect` function to ensure you don't add duplicate subscribers..
+  *
+  * ```jsx
+  * export const MyComponent = () => {
+  *   const x = useMotionValue(0)
+  *   const y = useMotionValue(0)
+  *   const opacity = useMotionValue(1)
+  *
+  *   useEffect(() => {
+  *     function updateOpacity() {
+  *       const maxXY = Math.max(x.get(), y.get())
+  *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+  *       opacity.set(newOpacity)
+  *     }
+  *
+  *     const unsubscribeX = x.on("change", updateOpacity)
+  *     const unsubscribeY = y.on("change", updateOpacity)
+  *
+  *     return () => {
+  *       unsubscribeX()
+  *       unsubscribeY()
+  *     }
+  *   }, [])
+  *
+  *   return <motion.div style={{ x }} />
+  * }
+  * ```
+  *
+  * @param subscriber - A function that receives the latest value.
+  * @returns A function that, when called, will cancel this subscription.
+  *
+  * @deprecated
+  */
+  onChange(subscription) {
+    return this.on("change", subscription);
+  }
+  on(eventName, callback) {
+    if (!this.events[eventName]) this.events[eventName] = new SubscriptionManager();
+    const unsubscribe = this.events[eventName].add(callback);
+    if (eventName === "change") return () => {
+      unsubscribe();
+      frame.read(() => {
+        if (!this.events.change.getSize()) this.stop();
+      });
+    };
+    return unsubscribe;
+  }
+  clearListeners() {
+    for (const eventManagers in this.events) this.events[eventManagers].clear();
+  }
+  /**
+  * Attaches a passive effect to the `MotionValue`.
+  */
+  attach(passiveEffect, stopPassiveEffect) {
+    this.passiveEffect = passiveEffect;
+    this.stopPassiveEffect = stopPassiveEffect;
+  }
+  /**
+  * Sets the state of the `MotionValue`.
+  *
+  * @remarks
+  *
+  * ```jsx
+  * const x = useMotionValue(0)
+  * x.set(10)
+  * ```
+  *
+  * @param latest - Latest value to set.
+  * @param render - Whether to notify render subscribers. Defaults to `true`
+  *
+  * @public
+  */
+  set(v) {
+    if (!this.passiveEffect) this.updateAndNotify(v);
+    else this.passiveEffect(v, this.updateAndNotify);
+  }
+  setWithVelocity(prev, current, delta) {
+    this.set(current);
+    this.prev = void 0;
+    this.prevFrameValue = prev;
+    this.prevUpdatedAt = this.updatedAt - delta;
+  }
+  /**
+  * Set the state of the `MotionValue`, stopping any active animations,
+  * effects, and resets velocity to `0`.
+  */
+  jump(v, endAnimation = true) {
+    this.updateAndNotify(v);
+    this.prev = v;
+    this.prevUpdatedAt = this.prevFrameValue = void 0;
+    endAnimation && this.stop();
+    if (this.stopPassiveEffect) this.stopPassiveEffect();
+  }
+  dirty() {
+    this.events.change?.notify(this.current);
+  }
+  addDependent(dependent) {
+    if (!this.dependents) this.dependents = /* @__PURE__ */ new Set();
+    this.dependents.add(dependent);
+  }
+  removeDependent(dependent) {
+    if (this.dependents) this.dependents.delete(dependent);
+  }
+  /**
+  * Returns the latest state of `MotionValue`
+  *
+  * @returns - The latest state of `MotionValue`
+  *
+  * @public
+  */
+  get() {
+    if (collectMotionValues.current) collectMotionValues.current.push(this);
+    return this.current;
+  }
+  /**
+  * @public
+  */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+  * Returns the latest velocity of `MotionValue`
+  *
+  * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+  *
+  * @public
+  */
+  getVelocity() {
+    const currentTime = time.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || currentTime - this.updatedAt > MAX_VELOCITY_DELTA) return 0;
+    const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);
+    return /* @__PURE__ */ velocityPerSecond(parseFloat(this.current) - parseFloat(this.prevFrameValue), delta);
+  }
+  /**
+  * Registers a new animation to control this `MotionValue`. Only one
+  * animation can drive a `MotionValue` at one time.
+  *
+  * ```jsx
+  * value.start()
+  * ```
+  *
+  * @param animation - A function that starts the provided animation
+  */
+  start(startAnimation) {
+    this.stop();
+    return new Promise((resolve) => {
+      this.hasAnimated = true;
+      this.animation = startAnimation(resolve);
+      if (this.events.animationStart) this.events.animationStart.notify();
+    }).then(() => {
+      if (this.events.animationComplete) this.events.animationComplete.notify();
+      this.clearAnimation();
+    });
+  }
+  /**
+  * Stop the currently active animation.
+  *
+  * @public
+  */
+  stop() {
+    if (this.animation) {
+      this.animation.stop();
+      if (this.events.animationCancel) this.events.animationCancel.notify();
+    }
+    this.clearAnimation();
+  }
+  /**
+  * Returns `true` if this value is currently animating.
+  *
+  * @public
+  */
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  /**
+  * Destroy and clean up subscribers to this `MotionValue`.
+  *
+  * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+  * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+  * created a `MotionValue` via the `motionValue` function.
+  *
+  * @public
+  */
+  destroy() {
+    this.dependents?.clear();
+    this.events.destroy?.notify();
+    this.clearListeners();
+    this.stop();
+    if (this.stopPassiveEffect) this.stopPassiveEffect();
+  }
+};
+function motionValue(init, options) {
+  return new MotionValue(init, options);
+}
+function getValueState(visualElement) {
+  const state = [{}, {}];
+  visualElement?.values.forEach((value, key) => {
+    state[0][key] = value.get();
+    state[1][key] = value.getVelocity();
+  });
+  return state;
+}
+function resolveVariantFromProps(props, definition, custom, visualElement) {
+  if (typeof definition === "function") {
+    const [current, velocity] = getValueState(visualElement);
+    definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
+  }
+  if (typeof definition === "string") definition = props.variants && props.variants[definition];
+  if (typeof definition === "function") {
+    const [current, velocity] = getValueState(visualElement);
+    definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
+  }
+  return definition;
+}
+var isMotionValue = (value) => Boolean(value && value.getVelocity);
+function camelToDash(str) {
+  return str.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`);
+}
+var optimizedAppearDataAttribute = "data-" + camelToDash("framerAppearId");
+var auto = {
+  test: (v) => v === "auto",
+  parse: (v) => v
+};
+var testValueType = (v) => (type) => type.test(v);
+var dimensionValueTypes = [
+  number,
+  px,
+  percent,
+  degrees,
+  vw,
+  vh,
+  auto
+];
+var findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));
+var maxDefaults = /* @__PURE__ */ new Set([
+  "brightness",
+  "contrast",
+  "saturate",
+  "opacity"
+]);
+function applyDefaultFilter(v) {
+  const [name, value] = v.slice(0, -1).split("(");
+  if (name === "drop-shadow") return v;
+  const [number2] = value.match(floatRegex) || [];
+  if (!number2) return v;
+  const unit = value.replace(number2, "");
+  let defaultValue = maxDefaults.has(name) ? 1 : 0;
+  if (number2 !== value) defaultValue *= 100;
+  return name + "(" + defaultValue + unit + ")";
+}
+var functionRegex = /\b([a-z-]*)\(.*?\)/gu;
+var filter = {
+  ...complex,
+  getAnimatableNone: (v) => {
+    const functions = v.match(functionRegex);
+    return functions ? functions.map(applyDefaultFilter).join(" ") : v;
+  }
+};
+var mask = {
+  ...complex,
+  getAnimatableNone: (v) => {
+    const parsed = complex.parse(v);
+    return complex.createTransformer(v)(parsed.map((v2) => typeof v2 === "number" ? 0 : typeof v2 === "object" ? {
+      ...v2,
+      alpha: 1
+    } : v2));
+  }
+};
+var int = {
+  ...number,
+  transform: Math.round
+};
+var numberValueTypes = {
+  borderWidth: px,
+  borderTopWidth: px,
+  borderRightWidth: px,
+  borderBottomWidth: px,
+  borderLeftWidth: px,
+  borderRadius: px,
+  borderTopLeftRadius: px,
+  borderTopRightRadius: px,
+  borderBottomRightRadius: px,
+  borderBottomLeftRadius: px,
+  width: px,
+  maxWidth: px,
+  height: px,
+  maxHeight: px,
+  top: px,
+  right: px,
+  bottom: px,
+  left: px,
+  inset: px,
+  insetBlock: px,
+  insetBlockStart: px,
+  insetBlockEnd: px,
+  insetInline: px,
+  insetInlineStart: px,
+  insetInlineEnd: px,
+  padding: px,
+  paddingTop: px,
+  paddingRight: px,
+  paddingBottom: px,
+  paddingLeft: px,
+  paddingBlock: px,
+  paddingBlockStart: px,
+  paddingBlockEnd: px,
+  paddingInline: px,
+  paddingInlineStart: px,
+  paddingInlineEnd: px,
+  margin: px,
+  marginTop: px,
+  marginRight: px,
+  marginBottom: px,
+  marginLeft: px,
+  marginBlock: px,
+  marginBlockStart: px,
+  marginBlockEnd: px,
+  marginInline: px,
+  marginInlineStart: px,
+  marginInlineEnd: px,
+  fontSize: px,
+  backgroundPositionX: px,
+  backgroundPositionY: px,
+  rotate: degrees,
+  /**
+  * Internal channel for `transition.path` orientToPath. Composed onto
+  * `rotate` at the transform-build sites so the user's `rotate` is
+  * never read or overwritten. Not part of `transformPropOrder`.
+  */
+  pathRotation: 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,
+  zIndex: int,
+  fillOpacity: alpha,
+  strokeOpacity: alpha,
+  numOctaves: int
+};
+var defaultValueTypes = {
+  ...numberValueTypes,
+  color,
+  backgroundColor: color,
+  outlineColor: color,
+  fill: color,
+  stroke: color,
+  borderColor: color,
+  borderTopColor: color,
+  borderRightColor: color,
+  borderBottomColor: color,
+  borderLeftColor: color,
+  filter,
+  WebkitFilter: filter,
+  mask,
+  WebkitMask: mask
+};
+var getDefaultValueType = (key) => defaultValueTypes[key];
+var customTypes = /* @__PURE__ */ new Set([filter, mask]);
+function getAnimatableNone(key, value) {
+  let defaultValueType = getDefaultValueType(key);
+  if (!customTypes.has(defaultValueType)) defaultValueType = complex;
+  return defaultValueType.getAnimatableNone ? defaultValueType.getAnimatableNone(value) : void 0;
+}
+var cornerRadiusProps = [
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderBottomRightRadius",
+  "borderBottomLeftRadius"
+];
+var getValueAsType = (value, type) => {
+  return type && typeof value === "number" ? type.transform(value) : value;
+};
+var { schedule: microtask, cancel: cancelMicrotask } = /* @__PURE__ */ createRenderBatcher(queueMicrotask, false);
+var valueTypes = [
+  ...dimensionValueTypes,
+  color,
+  complex
+];
+var findValueType = (v) => valueTypes.find(testValueType(v));
+var createAxisDelta = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+});
+var createDelta = () => ({
+  x: createAxisDelta(),
+  y: createAxisDelta()
+});
+var createAxis = () => ({
+  min: 0,
+  max: 0
+});
+var createBox = () => ({
+  x: createAxis(),
+  y: createAxis()
+});
+var visualElementStore = /* @__PURE__ */ new WeakMap();
+function isAnimationControls(v) {
+  return v !== null && typeof v === "object" && typeof v.start === "function";
+}
+function isVariantLabel(v) {
+  return typeof v === "string" || Array.isArray(v);
+}
+var variantPriorityOrder = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+];
+var variantProps = ["initial", ...variantPriorityOrder];
+function isControllingVariants(props) {
+  return isAnimationControls(props.animate) || variantProps.some((name) => isVariantLabel(props[name]));
+}
+function isVariantNode(props) {
+  return Boolean(isControllingVariants(props) || props.variants);
+}
+function updateMotionValuesFromProps(element, next, prev) {
+  for (const key in next) {
+    const nextValue = next[key];
+    const prevValue = prev[key];
+    if (isMotionValue(nextValue))
+      element.addValue(key, nextValue);
+    else if (isMotionValue(prevValue))
+      element.addValue(key, motionValue(nextValue, { owner: element }));
+    else if (prevValue !== nextValue) {
+      if (element.hasValue(key)) {
+        const existingValue = element.getValue(key);
+        if (existingValue.liveStyle === true) existingValue.jump(nextValue);
+        else if (!existingValue.hasAnimated) existingValue.set(nextValue);
+      } else {
+        const latestValue = element.getStaticValue(key);
+        element.addValue(key, motionValue(latestValue !== void 0 ? latestValue : nextValue, { owner: element }));
+      }
+    }
+  }
+  for (const key in prev) if (next[key] === void 0) element.removeValue(key);
+  return next;
+}
+var prefersReducedMotion = { current: null };
+var hasReducedMotionListener = { current: false };
+var isBrowser = typeof window !== "undefined";
+function initPrefersReducedMotion() {
+  hasReducedMotionListener.current = true;
+  if (!isBrowser) return;
+  if (window.matchMedia) {
+    const motionMediaQuery = window.matchMedia("(prefers-reduced-motion)");
+    const setReducedMotionPreferences = () => prefersReducedMotion.current = motionMediaQuery.matches;
+    motionMediaQuery.addEventListener("change", setReducedMotionPreferences);
+    setReducedMotionPreferences();
+  } else prefersReducedMotion.current = false;
+}
+var propEventHandlers = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+var featureDefinitions = {};
+function setFeatureDefinitions(definitions) {
+  featureDefinitions = definitions;
+}
+function getFeatureDefinitions() {
+  return featureDefinitions;
+}
+var VisualElement = class {
+  /**
+  * 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(_props, _prevProps, _visualElement) {
+    return {};
+  }
+  constructor({ parent, props, presenceContext, reducedMotionConfig, skipAnimations, blockInitialAnimation, visualState }, options = {}) {
+    this.current = null;
+    this.children = /* @__PURE__ */ new Set();
+    this.isVariantNode = false;
+    this.isControllingVariants = false;
+    this.shouldReduceMotion = null;
+    this.shouldSkipAnimations = false;
+    this.values = /* @__PURE__ */ new Map();
+    this.KeyframeResolver = KeyframeResolver;
+    this.features = {};
+    this.valueSubscriptions = /* @__PURE__ */ new Map();
+    this.prevMotionValues = {};
+    this.hasBeenMounted = false;
+    this.events = {};
+    this.propEventSubscriptions = {};
+    this.notifyUpdate = () => this.notify("Update", this.latestValues);
+    this.render = () => {
+      if (!this.current) return;
+      this.triggerBuild();
+      this.renderInstance(this.current, this.renderState, this.props.style, this.projection);
+    };
+    this.renderScheduledAt = 0;
+    this.scheduleRender = () => {
+      const now2 = time.now();
+      if (this.renderScheduledAt < now2) {
+        this.renderScheduledAt = now2;
+        frame.render(this.render, false, true);
+      }
+    };
+    const { latestValues, renderState } = visualState;
+    this.latestValues = latestValues;
+    this.baseTarget = { ...latestValues };
+    this.initialValues = props.initial ? { ...latestValues } : {};
+    this.renderState = renderState;
+    this.parent = parent;
+    this.props = props;
+    this.presenceContext = presenceContext;
+    this.depth = parent ? parent.depth + 1 : 0;
+    this.reducedMotionConfig = reducedMotionConfig;
+    this.skipAnimationsConfig = skipAnimations;
+    this.options = options;
+    this.blockInitialAnimation = Boolean(blockInitialAnimation);
+    this.isControllingVariants = isControllingVariants(props);
+    this.isVariantNode = isVariantNode(props);
+    if (this.isVariantNode) this.variantChildren = /* @__PURE__ */ new Set();
+    this.manuallyAnimateOnMount = Boolean(parent && parent.current);
+    const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);
+    for (const key in initialMotionValues) {
+      const value = initialMotionValues[key];
+      if (latestValues[key] !== void 0 && isMotionValue(value)) value.set(latestValues[key]);
+    }
+  }
+  mount(instance) {
+    if (this.hasBeenMounted) for (const key in this.initialValues) {
+      this.values.get(key)?.jump(this.initialValues[key]);
+      this.latestValues[key] = this.initialValues[key];
+    }
+    this.current = instance;
+    visualElementStore.set(instance, this);
+    if (this.projection && !this.projection.instance) this.projection.mount(instance);
+    if (this.parent && this.isVariantNode && !this.isControllingVariants) this.removeFromVariantTree = this.parent.addVariantChild(this);
+    this.values.forEach((value, key) => this.bindToMotionValue(key, value));
+    if (this.reducedMotionConfig === "never") this.shouldReduceMotion = false;
+    else if (this.reducedMotionConfig === "always") this.shouldReduceMotion = true;
+    else {
+      if (!hasReducedMotionListener.current) initPrefersReducedMotion();
+      this.shouldReduceMotion = prefersReducedMotion.current;
+    }
+    this.shouldSkipAnimations = this.skipAnimationsConfig ?? false;
+    this.parent?.addChild(this);
+    this.update(this.props, this.presenceContext);
+    this.hasBeenMounted = true;
+  }
+  unmount() {
+    this.projection && this.projection.unmount();
+    cancelFrame(this.notifyUpdate);
+    cancelFrame(this.render);
+    this.valueSubscriptions.forEach((remove) => remove());
+    this.valueSubscriptions.clear();
+    this.removeFromVariantTree && this.removeFromVariantTree();
+    this.parent?.removeChild(this);
+    for (const key in this.events) this.events[key].clear();
+    for (const key in this.features) {
+      const feature = this.features[key];
+      if (feature) {
+        feature.unmount();
+        feature.isMounted = false;
+      }
+    }
+    this.current = null;
+  }
+  addChild(child) {
+    this.children.add(child);
+    this.enteringChildren ?? (this.enteringChildren = /* @__PURE__ */ new Set());
+    this.enteringChildren.add(child);
+  }
+  removeChild(child) {
+    this.children.delete(child);
+    this.enteringChildren && this.enteringChildren.delete(child);
+  }
+  bindToMotionValue(key, value) {
+    if (this.valueSubscriptions.has(key)) this.valueSubscriptions.get(key)();
+    if (value.accelerate && acceleratedValues.has(key) && this.current instanceof HTMLElement) {
+      const { factory, keyframes, times, ease, duration } = value.accelerate;
+      const animation = new NativeAnimation({
+        element: this.current,
+        name: key,
+        keyframes,
+        times,
+        ease,
+        duration: /* @__PURE__ */ secondsToMilliseconds(duration)
+      });
+      const cleanup = factory(animation);
+      this.valueSubscriptions.set(key, () => {
+        cleanup();
+        animation.cancel();
+      });
+      return;
+    }
+    const valueIsTransform = transformProps.has(key);
+    if (valueIsTransform && this.onBindTransform) this.onBindTransform();
+    const removeOnChange = value.on("change", (latestValue) => {
+      this.latestValues[key] = latestValue;
+      this.props.onUpdate && frame.preRender(this.notifyUpdate);
+      if (valueIsTransform && this.projection) this.projection.isTransformDirty = true;
+      this.scheduleRender();
+    });
+    let removeSyncCheck;
+    if (typeof window !== "undefined" && window.MotionCheckAppearSync) removeSyncCheck = window.MotionCheckAppearSync(this, key, value);
+    this.valueSubscriptions.set(key, () => {
+      removeOnChange();
+      if (removeSyncCheck) removeSyncCheck();
+    });
+  }
+  sortNodePosition(other) {
+    if (!this.current || !this.sortInstanceNodePosition || this.type !== other.type) return 0;
+    return this.sortInstanceNodePosition(this.current, other.current);
+  }
+  updateFeatures() {
+    let key = "animation";
+    for (key in featureDefinitions) {
+      const featureDefinition = featureDefinitions[key];
+      if (!featureDefinition) continue;
+      const { isEnabled, Feature: FeatureConstructor } = featureDefinition;
+      if (!this.features[key] && FeatureConstructor && isEnabled(this.props)) this.features[key] = new FeatureConstructor(this);
+      if (this.features[key]) {
+        const feature = this.features[key];
+        if (feature.isMounted) feature.update();
+        else {
+          feature.mount();
+          feature.isMounted = true;
+        }
+      }
+    }
+  }
+  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) : createBox();
+  }
+  getStaticValue(key) {
+    return this.latestValues[key];
+  }
+  setStaticValue(key, value) {
+    this.latestValues[key] = value;
+  }
+  /**
+  * Update the provided props. Ensure any newly-added motion values are
+  * added to our map, old ones removed, and listeners updated.
+  */
+  update(props, presenceContext) {
+    if (props.transformTemplate || this.props.transformTemplate) this.scheduleRender();
+    this.prevProps = this.props;
+    this.props = props;
+    this.prevPresenceContext = this.presenceContext;
+    this.presenceContext = presenceContext;
+    for (let i = 0; i < propEventHandlers.length; i++) {
+      const key = propEventHandlers[i];
+      if (this.propEventSubscriptions[key]) {
+        this.propEventSubscriptions[key]();
+        delete this.propEventSubscriptions[key];
+      }
+      const listener = props["on" + key];
+      if (listener) this.propEventSubscriptions[key] = this.on(key, listener);
+    }
+    this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps || {}, this), this.prevMotionValues);
+    if (this.handleChildMotionValue) this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+  * Returns the variant definition with a given name.
+  */
+  getVariant(name) {
+    return this.props.variants ? this.props.variants[name] : 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(child) {
+    const closestVariantNode = this.getClosestVariantNode();
+    if (closestVariantNode) {
+      closestVariantNode.variantChildren && closestVariantNode.variantChildren.add(child);
+      return () => closestVariantNode.variantChildren.delete(child);
+    }
+  }
+  /**
+  * Add a motion value and bind it to this visual element.
+  */
+  addValue(key, value) {
+    const existingValue = this.values.get(key);
+    if (value !== existingValue) {
+      if (existingValue) this.removeValue(key);
+      this.bindToMotionValue(key, value);
+      this.values.set(key, value);
+      this.latestValues[key] = value.get();
+    }
+  }
+  /**
+  * Remove a motion value and unbind any active subscriptions.
+  */
+  removeValue(key) {
+    this.values.delete(key);
+    const unsubscribe = this.valueSubscriptions.get(key);
+    if (unsubscribe) {
+      unsubscribe();
+      this.valueSubscriptions.delete(key);
+    }
+    delete this.latestValues[key];
+    this.removeValueFromRenderState(key, this.renderState);
+  }
+  /**
+  * Check whether we have a motion value for this key
+  */
+  hasValue(key) {
+    return this.values.has(key);
+  }
+  getValue(key, defaultValue) {
+    if (this.props.values && this.props.values[key]) return this.props.values[key];
+    let value = this.values.get(key);
+    if (value === void 0 && defaultValue !== void 0) {
+      value = motionValue(defaultValue === null ? void 0 : defaultValue, { owner: this });
+      this.addValue(key, value);
+    }
+    return value;
+  }
+  /**
+  * 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(key, target) {
+    let value = this.latestValues[key] !== void 0 || !this.current ? this.latestValues[key] : this.getBaseTargetFromProps(this.props, key) ?? this.readValueFromInstance(this.current, key, this.options);
+    if (value !== void 0 && value !== null) {
+      if (typeof value === "string" && (isNumericalString(value) || isZeroValueString(value))) value = parseFloat(value);
+      else if (!findValueType(value) && complex.test(target)) value = getAnimatableNone(key, target);
+      this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);
+    }
+    return isMotionValue(value) ? value.get() : value;
+  }
+  /**
+  * Set the base target to later animate back to. This is currently
+  * only hydrated on creation and when we first read a value.
+  */
+  setBaseTarget(key, value) {
+    this.baseTarget[key] = value;
+  }
+  /**
+  * Find the base target for a value thats been removed from all animation
+  * props.
+  */
+  getBaseTarget(key) {
+    const { initial } = this.props;
+    let valueFromInitial;
+    if (typeof initial === "string" || typeof initial === "object") {
+      const variant = resolveVariantFromProps(this.props, initial, this.presenceContext?.custom);
+      if (variant) valueFromInitial = variant[key];
+    }
+    if (initial && valueFromInitial !== void 0) return valueFromInitial;
+    const target = this.getBaseTargetFromProps(this.props, key);
+    if (target !== void 0 && !isMotionValue(target)) return target;
+    return this.initialValues[key] !== void 0 && valueFromInitial === void 0 ? void 0 : this.baseTarget[key];
+  }
+  on(eventName, callback) {
+    if (!this.events[eventName]) this.events[eventName] = new SubscriptionManager();
+    return this.events[eventName].add(callback);
+  }
+  notify(eventName, ...args) {
+    if (this.events[eventName]) this.events[eventName].notify(...args);
+  }
+  scheduleRenderMicrotask() {
+    microtask.render(this.render);
+  }
+};
+var translateAlias = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+};
+var 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 {
+      const parsed = parseFloat(value);
+      valueIsDefault = key.startsWith("scale") ? parsed === 1 : parsed === 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;
+    }
+  }
+  const pathRotation = latestValues.pathRotation;
+  if (pathRotation) {
+    transformIsDefault = false;
+    transformString += `rotate(${getValueAsType(pathRotation, numberValueTypes.pathRotation)}) `;
+  }
+  transformString = transformString.trim();
+  if (transformTemplate) transformString = transformTemplate(transform, transformIsDefault ? "" : transformString);
+  else if (transformIsDefault) transformString = "none";
+  return transformString;
+}
+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}`;
+  }
+}
+function pixelsToPercent(pixels, axis) {
+  if (axis.max === axis.min) return 0;
+  return pixels / (axis.max - axis.min) * 100;
+}
+var correctBorderRadius = { correct: (latest, node) => {
+  if (!node.target) return latest;
+  if (typeof latest === "string") {
+    if (px.test(latest)) latest = parseFloat(latest);
+    else return latest;
+  }
+  return `${pixelsToPercent(latest, node.target.x)}% ${pixelsToPercent(latest, node.target.y)}%`;
+} };
+var correctBoxShadow = { correct: (latest, { treeScale, projectionDelta }) => {
+  const original = latest;
+  const shadow = complex.parse(latest);
+  if (shadow.length > 5) return original;
+  const template = complex.createTransformer(latest);
+  const offset = typeof shadow[0] !== "number" ? 1 : 0;
+  const xScale = projectionDelta.x.scale * treeScale.x;
+  const yScale = projectionDelta.y.scale * treeScale.y;
+  shadow[0 + offset] /= xScale;
+  shadow[1 + offset] /= yScale;
+  const averageScale = mixNumber(xScale, yScale, 0.5);
+  if (typeof shadow[2 + offset] === "number") shadow[2 + offset] /= averageScale;
+  if (typeof shadow[3 + offset] === "number") shadow[3 + offset] /= averageScale;
+  return template(shadow);
+} };
+var scaleCorrectors = {
+  borderRadius: {
+    ...correctBorderRadius,
+    applyTo: [...cornerRadiusProps]
+  },
+  borderTopLeftRadius: correctBorderRadius,
+  borderTopRightRadius: correctBorderRadius,
+  borderBottomLeftRadius: correctBorderRadius,
+  borderBottomRightRadius: correctBorderRadius,
+  boxShadow: correctBoxShadow
+};
+function isForcedMotionValue(key, { layout, layoutId }) {
+  return transformProps.has(key) || key.startsWith("origin") || (layout || layoutId !== void 0) && (!!scaleCorrectors[key] || key === "opacity");
+}
+function scrapeMotionValuesFromProps$1(props, prevProps, visualElement) {
+  const style = props.style;
+  const prevStyle = prevProps?.style;
+  const newValues = {};
+  if (!style) return newValues;
+  for (const key in style) if (isMotionValue(style[key]) || prevStyle && isMotionValue(prevStyle[key]) || isForcedMotionValue(key, props) || visualElement?.getValue(key)?.liveStyle !== void 0) newValues[key] = style[key];
+  return newValues;
+}
+var dashKeys = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+};
+var 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] = `${-offset}`;
+  attrs[keys.array] = `${length} ${spacing}`;
+}
+var cssStyleProperties = [
+  "transform",
+  "opacity",
+  "offsetDistance",
+  "offsetPath",
+  "offsetRotate",
+  "offsetAnchor"
+];
+function buildSVGAttrs(state, { attrX, attrY, attrScale, pathLength, pathSpacing = 1, pathOffset = 0, ...latest }, isSVGTag2, transformTemplate, styleProp) {
+  buildHTMLStyles(state, latest, transformTemplate);
+  if (isSVGTag2) {
+    if (state.style.viewBox) state.attrs.viewBox = state.style.viewBox;
+    return;
+  }
+  state.attrs = state.style;
+  state.style = {};
+  const { attrs, style } = state;
+  for (const key of cssStyleProperties) if (attrs[key] !== void 0) {
+    style[key] = attrs[key];
+    delete attrs[key];
+  }
+  if (style.transform || attrs.transformOrigin) {
+    style.transformOrigin = attrs.transformOrigin ?? "50% 50%";
+    delete attrs.transformOrigin;
+  }
+  if (style.transform) {
+    style.transformBox = styleProp?.transformBox ?? "fill-box";
+    delete attrs.transformBox;
+  }
+  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);
+}
+var isSVGTag = (tag) => typeof tag === "string" && tag.toLowerCase() === "svg";
+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;
+}
+function resolveMotionValue(value) {
+  return isMotionValue(value) ? value.get() : value;
+}
+var MotionConfigContext = createContext({
+  transformPagePoint: (p) => p,
+  isStatic: false,
+  reducedMotion: "never"
+});
+var LazyContext = createContext({ strict: false });
+var featureProps = {
+  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"]
+};
+var isInitialized = false;
+function initFeatureDefinitions() {
+  if (isInitialized) return;
+  const initialFeatureDefinitions = {};
+  for (const key in featureProps) initialFeatureDefinitions[key] = { isEnabled: (props) => featureProps[key].some((name) => !!props[name]) };
+  setFeatureDefinitions(initialFeatureDefinitions);
+  isInitialized = true;
+}
+function getInitializedFeatureDefinitions() {
+  initFeatureDefinitions();
+  return getFeatureDefinitions();
+}
+function loadFeatures(features) {
+  const featureDefinitions2 = getInitializedFeatureDefinitions();
+  for (const key in features) featureDefinitions2[key] = {
+    ...featureDefinitions2[key],
+    ...features[key]
+  };
+  setFeatureDefinitions(featureDefinitions2);
+}
+var lowercaseSVGElements = [
+  "animate",
+  "circle",
+  "defs",
+  "desc",
+  "ellipse",
+  "g",
+  "image",
+  "line",
+  "filter",
+  "marker",
+  "mask",
+  "metadata",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "switch",
+  "symbol",
+  "svg",
+  "text",
+  "tspan",
+  "use",
+  "view"
+];
+function isSVGComponent(Component) {
+  if (typeof Component !== "string" || Component.includes("-")) return false;
+  else if (lowercaseSVGElements.indexOf(Component) > -1 || /[A-Z]/u.test(Component)) return true;
+  return false;
+}
+var SwitchLayoutGroupContext = createContext({});
+function isRefObject(ref) {
+  return ref && typeof ref === "object" && Object.prototype.hasOwnProperty.call(ref, "current");
+}
+
+export {
+  LayoutGroupContext,
+  useConstant,
+  PresenceContext,
+  addUniqueItem,
+  removeItem,
+  clamp,
+  warning,
+  invariant,
+  MotionGlobalConfig,
+  isNumericalString,
+  isZeroValueString,
+  memo$1,
+  noop,
+  SubscriptionManager,
+  secondsToMilliseconds,
+  millisecondsToSeconds,
+  velocityPerSecond,
+  isBezierDefinition,
+  frame,
+  cancelFrame,
+  frameData,
+  frameSteps,
+  time,
+  isCSSVariableName,
+  isCSSVariableToken,
+  containsCSSVariable,
+  rgba,
+  hex,
+  percent,
+  px,
+  hsla,
+  color,
+  analyseComplexValue,
+  complex,
+  mixNumber,
+  generateLinearEasing,
+  getFinalKeyframe,
+  WithPromise,
+  defaultTransformValue,
+  readTransformValue,
+  transformPropOrder,
+  transformProps,
+  isNumOrPxType,
+  positionalValues,
+  flushKeyframeResolvers,
+  KeyframeResolver,
+  setStyle,
+  isGenerator,
+  NativeAnimation,
+  acceleratedValues,
+  motionValue,
+  resolveVariantFromProps,
+  isMotionValue,
+  camelToDash,
+  optimizedAppearDataAttribute,
+  findDimensionValueType,
+  getDefaultValueType,
+  getAnimatableNone,
+  cornerRadiusProps,
+  microtask,
+  createDelta,
+  createBox,
+  visualElementStore,
+  isAnimationControls,
+  isVariantLabel,
+  variantPriorityOrder,
+  variantProps,
+  isControllingVariants,
+  isVariantNode,
+  prefersReducedMotion,
+  hasReducedMotionListener,
+  initPrefersReducedMotion,
+  VisualElement,
+  buildHTMLStyles,
+  scaleCorrectors,
+  isForcedMotionValue,
+  scrapeMotionValuesFromProps$1,
+  cssStyleProperties,
+  buildSVGAttrs,
+  isSVGTag,
+  scrapeMotionValuesFromProps,
+  resolveMotionValue,
+  MotionConfigContext,
+  LazyContext,
+  getInitializedFeatureDefinitions,
+  loadFeatures,
+  isSVGComponent,
+  SwitchLayoutGroupContext,
+  isRefObject
+};