@quan-erp/shared-ui 1.0.0

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/html/utils/build-transform.js

@@ -0,0 +1,53 @@
+import { getValueAsType } from "../../../value/types/utils/get-as-type.js";
+import { numberValueTypes } from "../../../value/types/maps/number.js";
+import { transformPropOrder } from "../../utils/keys-transform.js";
+const translateAlias = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+};
+const numTransforms = transformPropOrder.length;
+function buildTransform(latestValues, transform, transformTemplate) {
+  let transformString = "";
+  let transformIsDefault = true;
+  for (let i = 0; i < numTransforms; i++) {
+    const key = transformPropOrder[i];
+    const value = latestValues[key];
+    if (value === void 0)
+      continue;
+    let valueIsDefault = true;
+    if (typeof value === "number") {
+      valueIsDefault = value === (key.startsWith("scale") ? 1 : 0);
+    } else {
+      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;
+}
+export {
+  buildTransform
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/html/utils/render.js

@@ -0,0 +1,14 @@
+function renderHTML(element, { style, vars }, styleProp, projection) {
+  const elementStyle = element.style;
+  let key;
+  for (key in style) {
+    elementStyle[key] = style[key];
+  }
+  projection?.applyProjectionStyles(elementStyle, styleProp);
+  for (key in vars) {
+    elementStyle.setProperty(key, vars[key]);
+  }
+}
+export {
+  renderHTML
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/html/utils/scrape-motion-values.js

@@ -0,0 +1,18 @@
+import { isMotionValue } from "../../../value/utils/is-motion-value.js";
+import { isForcedMotionValue } from "../../utils/is-forced-motion-value.js";
+function scrapeMotionValuesFromProps(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;
+}
+export {
+  scrapeMotionValuesFromProps
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/store.js

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

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/svg/SVGVisualElement.js

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

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/svg/utils/build-attrs.js

@@ -0,0 +1,59 @@
+import { buildHTMLStyles } from "../../html/utils/build-styles.js";
+import { buildSVGPath } from "./path.js";
+const cssMotionPathProperties = [
+  "offsetDistance",
+  "offsetPath",
+  "offsetRotate",
+  "offsetAnchor"
+];
+function buildSVGAttrs(state, {
+  attrX,
+  attrY,
+  attrScale,
+  pathLength,
+  pathSpacing = 1,
+  pathOffset = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...latest
+}, isSVGTag, transformTemplate, styleProp) {
+  buildHTMLStyles(state, latest, transformTemplate);
+  if (isSVGTag) {
+    if (state.style.viewBox) {
+      state.attrs.viewBox = state.style.viewBox;
+    }
+    return;
+  }
+  state.attrs = state.style;
+  state.style = {};
+  const { attrs, style } = state;
+  if (attrs.transform) {
+    style.transform = attrs.transform;
+    delete attrs.transform;
+  }
+  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;
+  }
+  for (const key of cssMotionPathProperties) {
+    if (attrs[key] !== void 0) {
+      style[key] = attrs[key];
+      delete attrs[key];
+    }
+  }
+  if (attrX !== void 0)
+    attrs.x = attrX;
+  if (attrY !== void 0)
+    attrs.y = attrY;
+  if (attrScale !== void 0)
+    attrs.scale = attrScale;
+  if (pathLength !== void 0) {
+    buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);
+  }
+}
+export {
+  buildSVGAttrs
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/svg/utils/camel-case-attrs.js

@@ -0,0 +1,28 @@
+const camelCaseAttributes = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform",
+  "pathLength",
+  "startOffset",
+  "textLength",
+  "lengthAdjust"
+]);
+export {
+  camelCaseAttributes
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/svg/utils/is-svg-tag.js

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

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/svg/utils/path.js

@@ -0,0 +1,17 @@
+const dashKeys = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+};
+const camelKeys = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function buildSVGPath(attrs, length, spacing = 1, offset = 0, useDashCase = true) {
+  attrs.pathLength = 1;
+  const keys = useDashCase ? dashKeys : camelKeys;
+  attrs[keys.offset] = `${-offset}`;
+  attrs[keys.array] = `${length} ${spacing}`;
+}
+export {
+  buildSVGPath
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/svg/utils/render.js

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

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/svg/utils/scrape-motion-values.js

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

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/animation-state.js

@@ -0,0 +1,223 @@
+import { animateVisualElement } from "../../animation/interfaces/visual-element.js";
+import { calcChildStagger } from "../../animation/utils/calc-child-stagger.js";
+import { getVariantContext } from "./get-variant-context.js";
+import { isAnimationControls } from "./is-animation-controls.js";
+import { isKeyframesTarget } from "./is-keyframes-target.js";
+import { isVariantLabel } from "./is-variant-label.js";
+import { resolveVariant } from "./resolve-dynamic-variants.js";
+import { shallowCompare } from "./shallow-compare.js";
+import { variantPriorityOrder } from "./variant-props.js";
+const reversePriorityOrder = [...variantPriorityOrder].reverse();
+const numAnimationTypes = variantPriorityOrder.length;
+function createAnimateFunction(visualElement) {
+  return (animations) => {
+    return Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));
+  };
+}
+function createAnimationState(visualElement) {
+  let animate = createAnimateFunction(visualElement);
+  let state = createState();
+  let isInitialRender = true;
+  let wasReset = false;
+  const buildResolvedTypeValues = (type) => (acc, definition) => {
+    const resolved = resolveVariant(visualElement, definition, type === "exit" ? visualElement.presenceContext?.custom : void 0);
+    if (resolved) {
+      const { transition, transitionEnd, ...target } = resolved;
+      acc = { ...acc, ...target, ...transitionEnd };
+    }
+    return acc;
+  };
+  function setAnimateFunction(makeAnimator) {
+    animate = makeAnimator(visualElement);
+  }
+  function animateChanges(changedActiveType) {
+    const { props } = visualElement;
+    const context = getVariantContext(visualElement.parent) || {};
+    const animations = [];
+    const removedKeys = /* @__PURE__ */ new Set();
+    let encounteredKeys = {};
+    let removedVariantIndex = Infinity;
+    for (let i = 0; i < numAnimationTypes; i++) {
+      const type = reversePriorityOrder[i];
+      const typeState = state[type];
+      const prop = props[type] !== void 0 ? props[type] : context[type];
+      const propIsVariant = isVariantLabel(prop);
+      const activeDelta = type === changedActiveType ? typeState.isActive : null;
+      if (activeDelta === false)
+        removedVariantIndex = i;
+      let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;
+      if (isInherited && (isInitialRender || wasReset) && visualElement.manuallyAnimateOnMount) {
+        isInherited = false;
+      }
+      typeState.protectedKeys = { ...encounteredKeys };
+      if (
+        // If it isn't active and hasn't *just* been set as inactive
+        !typeState.isActive && activeDelta === null || // If we didn't and don't have any defined prop for this animation type
+        !prop && !typeState.prevProp || // Or if the prop doesn't define an animation
+        isAnimationControls(prop) || typeof prop === "boolean"
+      ) {
+        continue;
+      }
+      if (type === "exit" && typeState.isActive && activeDelta !== true) {
+        if (typeState.prevResolvedValues) {
+          encounteredKeys = {
+            ...encounteredKeys,
+            ...typeState.prevResolvedValues
+          };
+        }
+        continue;
+      }
+      const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);
+      let shouldAnimateType = variantDidChange || // If we're making this variant active, we want to always make it active
+      type === changedActiveType && typeState.isActive && !isInherited && propIsVariant || // If we removed a higher-priority variant (i is in reverse order)
+      i > removedVariantIndex && propIsVariant;
+      let handledRemovedValues = false;
+      const definitionList = Array.isArray(prop) ? prop : [prop];
+      let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});
+      if (activeDelta === false)
+        resolvedValues = {};
+      const { prevResolvedValues = {} } = typeState;
+      const allKeys = {
+        ...prevResolvedValues,
+        ...resolvedValues
+      };
+      const markToAnimate = (key) => {
+        shouldAnimateType = true;
+        if (removedKeys.has(key)) {
+          handledRemovedValues = true;
+          removedKeys.delete(key);
+        }
+        typeState.needsAnimating[key] = true;
+        const motionValue = visualElement.getValue(key);
+        if (motionValue)
+          motionValue.liveStyle = false;
+      };
+      for (const key in allKeys) {
+        const next = resolvedValues[key];
+        const prev = prevResolvedValues[key];
+        if (encounteredKeys.hasOwnProperty(key))
+          continue;
+        let valueHasChanged = false;
+        if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {
+          valueHasChanged = !shallowCompare(next, prev) || variantDidChange;
+        } else {
+          valueHasChanged = next !== prev;
+        }
+        if (valueHasChanged) {
+          if (next !== void 0 && next !== null) {
+            markToAnimate(key);
+          } else {
+            removedKeys.add(key);
+          }
+        } else if (next !== void 0 && removedKeys.has(key)) {
+          markToAnimate(key);
+        } else {
+          typeState.protectedKeys[key] = true;
+        }
+      }
+      typeState.prevProp = prop;
+      typeState.prevResolvedValues = resolvedValues;
+      if (typeState.isActive) {
+        encounteredKeys = { ...encounteredKeys, ...resolvedValues };
+      }
+      if ((isInitialRender || wasReset) && visualElement.blockInitialAnimation) {
+        shouldAnimateType = false;
+      }
+      const willAnimateViaParent = isInherited && variantDidChange;
+      const needsAnimating = !willAnimateViaParent || handledRemovedValues;
+      if (shouldAnimateType && needsAnimating) {
+        animations.push(...definitionList.map((animation) => {
+          const options = { type };
+          if (typeof animation === "string" && (isInitialRender || wasReset) && !willAnimateViaParent && visualElement.manuallyAnimateOnMount && visualElement.parent) {
+            const { parent } = visualElement;
+            const parentVariant = resolveVariant(parent, animation);
+            if (parent.enteringChildren && parentVariant) {
+              const { delayChildren } = parentVariant.transition || {};
+              options.delay = calcChildStagger(parent.enteringChildren, visualElement, delayChildren);
+            }
+          }
+          return {
+            animation,
+            options
+          };
+        }));
+      }
+    }
+    if (removedKeys.size) {
+      const fallbackAnimation = {};
+      if (typeof props.initial !== "boolean") {
+        const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial) ? props.initial[0] : props.initial);
+        if (initialTransition && initialTransition.transition) {
+          fallbackAnimation.transition = initialTransition.transition;
+        }
+      }
+      removedKeys.forEach((key) => {
+        const fallbackTarget = visualElement.getBaseTarget(key);
+        const motionValue = visualElement.getValue(key);
+        if (motionValue)
+          motionValue.liveStyle = true;
+        fallbackAnimation[key] = fallbackTarget ?? null;
+      });
+      animations.push({ animation: fallbackAnimation });
+    }
+    let shouldAnimate = Boolean(animations.length);
+    if (isInitialRender && (props.initial === false || props.initial === props.animate) && !visualElement.manuallyAnimateOnMount) {
+      shouldAnimate = false;
+    }
+    isInitialRender = false;
+    wasReset = false;
+    return shouldAnimate ? animate(animations) : Promise.resolve();
+  }
+  function setActive(type, isActive) {
+    if (state[type].isActive === isActive)
+      return Promise.resolve();
+    visualElement.variantChildren?.forEach((child) => child.animationState?.setActive(type, isActive));
+    state[type].isActive = isActive;
+    const animations = animateChanges(type);
+    for (const key in state) {
+      state[key].protectedKeys = {};
+    }
+    return animations;
+  }
+  return {
+    animateChanges,
+    setActive,
+    setAnimateFunction,
+    getState: () => state,
+    reset: () => {
+      state = createState();
+      wasReset = true;
+    }
+  };
+}
+function checkVariantsDidChange(prev, next) {
+  if (typeof next === "string") {
+    return next !== prev;
+  } else if (Array.isArray(next)) {
+    return !shallowCompare(next, prev);
+  }
+  return false;
+}
+function createTypeState(isActive = false) {
+  return {
+    isActive,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function createState() {
+  return {
+    animate: createTypeState(true),
+    whileInView: createTypeState(),
+    whileHover: createTypeState(),
+    whileTap: createTypeState(),
+    whileDrag: createTypeState(),
+    whileFocus: createTypeState(),
+    exit: createTypeState()
+  };
+}
+export {
+  checkVariantsDidChange,
+  createAnimationState
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/get-variant-context.js

@@ -0,0 +1,26 @@
+import { isVariantLabel } from "./is-variant-label.js";
+import { variantProps } from "./variant-props.js";
+const numVariantProps = variantProps.length;
+function getVariantContext(visualElement) {
+  if (!visualElement)
+    return void 0;
+  if (!visualElement.isControllingVariants) {
+    const context2 = visualElement.parent ? getVariantContext(visualElement.parent) || {} : {};
+    if (visualElement.props.initial !== void 0) {
+      context2.initial = visualElement.props.initial;
+    }
+    return context2;
+  }
+  const context = {};
+  for (let i = 0; i < numVariantProps; i++) {
+    const name = variantProps[i];
+    const prop = visualElement.props[name];
+    if (isVariantLabel(prop) || prop === false) {
+      context[name] = prop;
+    }
+  }
+  return context;
+}
+export {
+  getVariantContext
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.js

@@ -0,0 +1,6 @@
+function isAnimationControls(v) {
+  return v !== null && typeof v === "object" && typeof v.start === "function";
+}
+export {
+  isAnimationControls
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/is-controlling-variants.js

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

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/is-forced-motion-value.js

@@ -0,0 +1,9 @@
+import { transformProps } from "./keys-transform.js";
+import { scaleCorrectors } from "../../projection/styles/scale-correction.js";
+function isForcedMotionValue(key, { layout, layoutId }) {
+  return transformProps.has(key) || key.startsWith("origin") || (layout || layoutId !== void 0) && (!!scaleCorrectors[key] || key === "opacity");
+}
+export {
+  isForcedMotionValue,
+  scaleCorrectors
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/is-keyframes-target.js

@@ -0,0 +1,6 @@
+const isKeyframesTarget = (v) => {
+  return Array.isArray(v);
+};
+export {
+  isKeyframesTarget
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/is-variant-label.js

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

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/keys-position.js

@@ -0,0 +1,13 @@
+import { transformPropOrder } from "./keys-transform.js";
+const positionalKeys = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...transformPropOrder
+]);
+export {
+  positionalKeys
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/keys-transform.js

@@ -0,0 +1,24 @@
+const transformPropOrder = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+];
+const transformProps = /* @__PURE__ */ (() => /* @__PURE__ */ new Set([...transformPropOrder, "pathRotation"]))();
+export {
+  transformPropOrder,
+  transformProps
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/render/utils/motion-values.js

@@ -0,0 +1,33 @@
+import { motionValue } from "../../value/index.js";
+import { isMotionValue } from "../../value/utils/is-motion-value.js";
+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;
+}
+export {
+  updateMotionValuesFromProps
+};