@vuu-ui/vuu-utils 4.0.1 → 4.1.1

package/src/vendor/@dnd-kit/dom/utilities.js

@@ -19,18 +19,17 @@ function isKeyframeEffect(effect) {
 // src/utilities/animations/getFinalKeyframe.ts
 function getFinalKeyframe(element, match) {
   const animations2 = element.getAnimations();
-  if (animations2.length > 0) {
-    for (const animation of animations2) {
-      if (animation.playState !== "running") continue;
-      const { effect } = animation;
-      const keyframes = isKeyframeEffect(effect) ? effect.getKeyframes() : [];
-      const matchedKeyframes = keyframes.filter(match);
-      if (matchedKeyframes.length > 0) {
-        return [matchedKeyframes[matchedKeyframes.length - 1], animation];
-      }
+  let result = null;
+  for (const animation of animations2) {
+    if (animation.playState !== "running") continue;
+    const { effect } = animation;
+    const keyframes = isKeyframeEffect(effect) ? effect.getKeyframes() : [];
+    const matchedKeyframes = keyframes.filter(match);
+    if (matchedKeyframes.length > 0) {
+      result = [matchedKeyframes[matchedKeyframes.length - 1], animation];
     }
   }
-  return null;
+  return result;
 }
 
 // src/utilities/bounding-rectangle/getBoundingRectangle.ts
@@ -39,9 +38,6 @@ function getBoundingRectangle(element) {
   return { width, height, top, left, bottom, right };
 }
 
-// src/utilities/execution-context/canUseDOM.ts
-var canUseDOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
-
 // src/utilities/type-guards/isWindow.ts
 function isWindow(element) {
   const elementString = Object.prototype.toString.call(element);
@@ -74,8 +70,8 @@ function getWindow(target) {
 
 // src/utilities/type-guards/isDocument.ts
 function isDocument(node) {
-  const { Document } = getWindow(node);
-  return node instanceof Document || "nodeType" in node && node.nodeType === Node.DOCUMENT_NODE;
+  const { Document: Document2 } = getWindow(node);
+  return node instanceof Document2 || "nodeType" in node && node.nodeType === Node.DOCUMENT_NODE;
 }
 
 // src/utilities/type-guards/isHTMLElement.ts
@@ -111,14 +107,18 @@ function getDocument(target) {
 
 // src/utilities/bounding-rectangle/getViewportBoundingRectangle.ts
 function getViewportBoundingRectangle(element) {
+  var _a, _b, _c, _d;
   const { documentElement } = getDocument(element);
-  const width = documentElement.clientWidth;
-  const height = documentElement.clientHeight;
+  const vv = getWindow(element).visualViewport;
+  const width = (_a = vv == null ? void 0 : vv.width) != null ? _a : documentElement.clientWidth;
+  const height = (_b = vv == null ? void 0 : vv.height) != null ? _b : documentElement.clientHeight;
+  const top = (_c = vv == null ? void 0 : vv.offsetTop) != null ? _c : 0;
+  const left = (_d = vv == null ? void 0 : vv.offsetLeft) != null ? _d : 0;
   return {
-    top: 0,
-    left: 0,
-    right: width,
-    bottom: height,
+    top,
+    left,
+    right: left + width,
+    bottom: top + height,
     width,
     height
   };
@@ -138,7 +138,7 @@ function isDetailsElement(element) {
 
 // src/utilities/bounding-rectangle/getVisibleBoundingRectangle.ts
 function getVisibleBoundingRectangle(element, boundingClientRect = element.getBoundingClientRect(), margin = 0) {
-  var _a;
+  var _a, _b, _c, _d, _e;
   let rect = boundingClientRect;
   const { ownerDocument } = element;
   const ownerWindow = (_a = ownerDocument.defaultView) != null ? _a : window;
@@ -165,15 +165,24 @@ function getVisibleBoundingRectangle(element, boundingClientRect = element.getBo
     }
     ancestor = ancestor.parentElement;
   }
-  const viewportWidth = ownerWindow.innerWidth;
-  const viewportHeight = ownerWindow.innerHeight;
+  const vv = ownerWindow.visualViewport;
+  const viewportTop = (_b = vv == null ? void 0 : vv.offsetTop) != null ? _b : 0;
+  const viewportLeft = (_c = vv == null ? void 0 : vv.offsetLeft) != null ? _c : 0;
+  const viewportWidth = (_d = vv == null ? void 0 : vv.width) != null ? _d : ownerWindow.innerWidth;
+  const viewportHeight = (_e = vv == null ? void 0 : vv.height) != null ? _e : ownerWindow.innerHeight;
   const viewportMarginY = margin * viewportHeight;
   const viewportMarginX = margin * viewportWidth;
   rect = {
-    top: Math.max(rect.top, 0 - viewportMarginY),
-    right: Math.min(rect.right, viewportWidth + viewportMarginX),
-    bottom: Math.min(rect.bottom, viewportHeight + viewportMarginY),
-    left: Math.max(rect.left, 0 - viewportMarginX),
+    top: Math.max(rect.top, viewportTop - viewportMarginY),
+    right: Math.min(
+      rect.right,
+      viewportLeft + viewportWidth + viewportMarginX
+    ),
+    bottom: Math.min(
+      rect.bottom,
+      viewportTop + viewportHeight + viewportMarginY
+    ),
+    left: Math.max(rect.left, viewportLeft - viewportMarginX),
     width: 0,
     // Will be calculated next
     height: 0
@@ -190,11 +199,85 @@ function getVisibleBoundingRectangle(element, boundingClientRect = element.getBo
   return rect;
 }
 
+// src/utilities/coordinates/getEventCoordinates.ts
+function getEventCoordinates(event) {
+  return {
+    x: event.clientX,
+    y: event.clientY
+  };
+}
+
+// src/utilities/execution-context/canUseDOM.ts
+var canUseDOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+
+// src/utilities/execution-context/getDocuments.ts
+function getDocuments(rootDoc = document, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(rootDoc)) return [];
+  seen.add(rootDoc);
+  const docs = [rootDoc];
+  for (const frame of Array.from(
+    rootDoc.querySelectorAll("iframe, frame")
+  )) {
+    try {
+      const childDoc = frame.contentDocument;
+      if (childDoc && !seen.has(childDoc)) {
+        docs.push(...getDocuments(childDoc, seen));
+      }
+    } catch (e) {
+    }
+  }
+  try {
+    const win = rootDoc.defaultView;
+    if (win && win !== window.top) {
+      const parentWin = win.parent;
+      if (parentWin && parentWin.document && parentWin.document !== rootDoc) {
+        docs.push(...getDocuments(parentWin.document, seen));
+      }
+    }
+  } catch (e) {
+  }
+  return docs;
+}
+
 // src/utilities/execution-context/isSafari.ts
 function isSafari() {
   return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
 }
 
+// src/utilities/execution-context/getFixedPositionOffset.ts
+function getFixedPositionOffset() {
+  var _a, _b;
+  const vv = isSafari() ? window.visualViewport : null;
+  return {
+    x: (_a = vv == null ? void 0 : vv.offsetLeft) != null ? _a : 0,
+    y: (_b = vv == null ? void 0 : vv.offsetTop) != null ? _b : 0
+  };
+}
+
+// src/utilities/type-guards/isShadowRoot.ts
+function isShadowRoot(target) {
+  if (!target || !isNode(target)) return false;
+  return target instanceof getWindow(target).ShadowRoot;
+}
+
+// src/utilities/execution-context/getRoot.ts
+function getRoot(target) {
+  if (target && isNode(target)) {
+    let root = target.getRootNode();
+    if (isShadowRoot(root)) {
+      return root;
+    } else if (root instanceof Document) {
+      return root;
+    }
+  }
+  return getDocument(target);
+}
+
+// src/utilities/execution-context/prefersReducedMotion.ts
+function prefersReducedMotion(window2) {
+  return window2.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+
 // src/utilities/element/cloneElement.ts
 function cloneElement(element) {
   const selector = "input, textarea, select, canvas, [contenteditable]";
@@ -226,8 +309,8 @@ function isCanvasElement(element) {
 }
 
 // src/utilities/element/getElementFromPoint.ts
-function getElementFromPoint(document2, { x, y }) {
-  const element = document2.elementFromPoint(x, y);
+function getElementFromPoint(root, { x, y }) {
+  const element = root.elementFromPoint(x, y);
   if (isIFrameElement(element)) {
     const { contentDocument } = element;
     if (contentDocument) {
@@ -247,6 +330,21 @@ function isIFrameElement(element) {
 // src/utilities/element/proxiedElements.ts
 var ProxiedElements = /* @__PURE__ */ new WeakMap();
 
+// src/utilities/element/isInteractiveElement.ts
+function isInteractiveElement(element) {
+  return Boolean(getInteractiveElement(element));
+}
+function getInteractiveElement(element) {
+  return element.closest(`
+    input:not([disabled]),
+    select:not([disabled]),
+    textarea:not([disabled]),
+    button:not([disabled]),
+    a[href],
+    [contenteditable]:not([contenteditable="false"])
+  `);
+}
+
 // src/utilities/event-listeners/Listeners.ts
 var Listeners = class {
   constructor() {
@@ -260,18 +358,24 @@ var Listeners = class {
     };
   }
   bind(target, input) {
+    const eventTargets = Array.isArray(target) ? target : [target];
     const listeners = Array.isArray(input) ? input : [input];
     const entries = [];
-    for (const descriptor of listeners) {
-      const { type, listener, options } = descriptor;
-      const entry = [target, descriptor];
-      target.addEventListener(type, listener, options);
-      this.entries.add(entry);
-      entries.push(entry);
+    for (const target2 of eventTargets) {
+      for (const descriptor of listeners) {
+        const { type, listener, options } = descriptor;
+        const entry = [target2, descriptor];
+        target2.addEventListener(type, listener, options);
+        this.entries.add(entry);
+        entries.push(entry);
+      }
     }
+    const allEntries = this.entries;
     return function cleanup() {
-      for (const [target2, { type, listener, options }] of entries) {
+      for (const entry of entries) {
+        const [target2, { type, listener, options }] = entry;
         target2.removeEventListener(type, listener, options);
+        allEntries.delete(entry);
       }
     };
   }
@@ -342,7 +446,7 @@ function isVisible(element, boundingClientRect = element.getBoundingClientRect()
 }
 
 // src/utilities/observers/ResizeNotifier.ts
-var Observer = canUseDOM ? ResizeObserver : class MockResizeObserver {
+var Observer = typeof ResizeObserver !== "undefined" ? ResizeObserver : class MockResizeObserver {
   observe() {
   }
   unobserve() {
@@ -653,11 +757,13 @@ function isDocumentScrollingElement(element) {
 
 // src/utilities/scroll/getScrollPosition.ts
 function getScrollPosition(scrollableElement) {
+  var _a, _b;
   const window2 = getWindow(scrollableElement);
   const rect = isDocumentScrollingElement(scrollableElement) ? getViewportBoundingRectangle(scrollableElement) : getBoundingRectangle(scrollableElement);
+  const vv = window2.visualViewport;
   const dimensions = isDocumentScrollingElement(scrollableElement) ? {
-    height: window2.innerHeight,
-    width: window2.innerWidth
+    height: (_a = vv == null ? void 0 : vv.height) != null ? _a : window2.innerHeight,
+    width: (_b = vv == null ? void 0 : vv.width) != null ? _b : window2.innerWidth
   } : {
     height: scrollableElement.clientHeight,
     width: scrollableElement.clientWidth
@@ -687,8 +793,8 @@ function getScrollPosition(scrollableElement) {
 }
 
 // src/utilities/scroll/canScroll.ts
-function canScroll(scrollableElement, by) {
-  const { isTop, isBottom, isLeft, isRight, position } = getScrollPosition(scrollableElement);
+function canScroll(scrollableElement, by, scrollPosition = getScrollPosition(scrollableElement)) {
+  const { isTop, isBottom, isLeft, isRight, position } = scrollPosition;
   const { x, y } = by != null ? by : { x: 0, y: 0 };
   const top = !isTop && position.current.y + y > 0;
   const bottom = !isBottom && position.current.y + y < position.max.y;
@@ -775,10 +881,11 @@ function isScrollable(element, computedStyle = getComputedStyles(element, true))
 
 // src/utilities/scroll/getScrollableAncestors.ts
 var defaultOptions = {
-  excludeElement: true
+  excludeElement: true,
+  escapeShadowDOM: true
 };
 function getScrollableAncestors(element, options = defaultOptions) {
-  const { limit, excludeElement } = options;
+  const { limit, excludeElement, escapeShadowDOM } = options;
   const scrollParents = /* @__PURE__ */ new Set();
   function findScrollableAncestors(node) {
     if (limit != null && scrollParents.size >= limit) {
@@ -791,6 +898,9 @@ function getScrollableAncestors(element, options = defaultOptions) {
       scrollParents.add(node.scrollingElement);
       return scrollParents;
     }
+    if (escapeShadowDOM && isShadowRoot(node)) {
+      return findScrollableAncestors(node.host);
+    }
     if (!isHTMLElement(node)) {
       if (isSVGElement(node)) {
         return findScrollableAncestors(node.parentElement);
@@ -863,7 +973,7 @@ function getScale(element, boundingRectangle = getBoundingRectangle(element)) {
 
 // src/utilities/transform/parseScale.ts
 function parseScale(scale) {
-  if (scale === "none") {
+  if (!scale || scale === "none") {
     return null;
   }
   const values = scale.split(" ");
@@ -880,7 +990,7 @@ function parseScale(scale) {
 
 // src/utilities/transform/parseTranslate.ts
 function parseTranslate(translate) {
-  if (translate === "none") {
+  if (!translate || translate === "none") {
     return null;
   }
   const [x, y, z = "0"] = translate.split(" ");
@@ -963,9 +1073,9 @@ var defaultTolerance = {
   x: 10,
   y: 10
 };
-function detectScrollIntent(scrollableElement, coordinates, intent, acceleration = 25, thresholdPercentage = defaultThreshold, tolerance = defaultTolerance) {
+function detectScrollIntent(scrollableElement, coordinates, intent, acceleration = 25, thresholdPercentage = defaultThreshold, tolerance = defaultTolerance, scrollPosition = getScrollPosition(scrollableElement)) {
   const { x, y } = coordinates;
-  const { rect, isTop, isBottom, isLeft, isRight } = getScrollPosition(scrollableElement);
+  const { rect, isTop, isBottom, isLeft, isRight } = scrollPosition;
   const frameTransform = getFrameTransform(scrollableElement);
   const computedStyles = getComputedStyles(scrollableElement, true);
   const parsedTransform = parseTransform(computedStyles);
@@ -989,23 +1099,23 @@ function detectScrollIntent(scrollableElement, coordinates, intent, acceleration
     height: scrollContainerRect.height * thresholdPercentage.y,
     width: scrollContainerRect.width * thresholdPercentage.x
   };
-  if ((!isTop || isYAxisInverted && !isBottom) && y <= scrollContainerRect.top + threshold2.height && (intent == null ? void 0 : intent.y) !== 1 /* Forward */ && x >= scrollContainerRect.left - tolerance.x && x <= scrollContainerRect.right + tolerance.x) {
+  if (threshold2.height > 0 && (!isTop || isYAxisInverted && !isBottom) && y <= scrollContainerRect.top + threshold2.height && (intent == null ? void 0 : intent.y) !== 1 /* Forward */ && x >= scrollContainerRect.left - tolerance.x && x <= scrollContainerRect.right + tolerance.x) {
     direction.y = isYAxisInverted ? 1 /* Forward */ : -1 /* Reverse */;
     speed.y = acceleration * Math.abs(
       (scrollContainerRect.top + threshold2.height - y) / threshold2.height
     );
-  } else if ((!isBottom || isYAxisInverted && !isTop) && y >= scrollContainerRect.bottom - threshold2.height && (intent == null ? void 0 : intent.y) !== -1 /* Reverse */ && x >= scrollContainerRect.left - tolerance.x && x <= scrollContainerRect.right + tolerance.x) {
+  } else if (threshold2.height > 0 && (!isBottom || isYAxisInverted && !isTop) && y >= scrollContainerRect.bottom - threshold2.height && (intent == null ? void 0 : intent.y) !== -1 /* Reverse */ && x >= scrollContainerRect.left - tolerance.x && x <= scrollContainerRect.right + tolerance.x) {
     direction.y = isYAxisInverted ? -1 /* Reverse */ : 1 /* Forward */;
     speed.y = acceleration * Math.abs(
       (scrollContainerRect.bottom - threshold2.height - y) / threshold2.height
     );
   }
-  if ((!isRight || isXAxisInverted && !isLeft) && x >= scrollContainerRect.right - threshold2.width && (intent == null ? void 0 : intent.x) !== -1 /* Reverse */ && y >= scrollContainerRect.top - tolerance.y && y <= scrollContainerRect.bottom + tolerance.y) {
+  if (threshold2.width > 0 && (!isRight || isXAxisInverted && !isLeft) && x >= scrollContainerRect.right - threshold2.width && (intent == null ? void 0 : intent.x) !== -1 /* Reverse */ && y >= scrollContainerRect.top - tolerance.y && y <= scrollContainerRect.bottom + tolerance.y) {
     direction.x = isXAxisInverted ? -1 /* Reverse */ : 1 /* Forward */;
     speed.x = acceleration * Math.abs(
       (scrollContainerRect.right - threshold2.width - x) / threshold2.width
     );
-  } else if ((!isLeft || isXAxisInverted && !isRight) && x <= scrollContainerRect.left + threshold2.width && (intent == null ? void 0 : intent.x) !== 1 /* Forward */ && y >= scrollContainerRect.top - tolerance.y && y <= scrollContainerRect.bottom + tolerance.y) {
+  } else if (threshold2.width > 0 && (!isLeft || isXAxisInverted && !isRight) && x <= scrollContainerRect.left + threshold2.width && (intent == null ? void 0 : intent.x) !== 1 /* Forward */ && y >= scrollContainerRect.top - tolerance.y && y <= scrollContainerRect.bottom + tolerance.y) {
     direction.x = isXAxisInverted ? 1 /* Forward */ : -1 /* Reverse */;
     speed.x = acceleration * Math.abs(
       (scrollContainerRect.left + threshold2.width - x) / threshold2.width
@@ -1018,35 +1128,76 @@ function detectScrollIntent(scrollableElement, coordinates, intent, acceleration
 }
 
 // src/utilities/scroll/scrollIntoViewIfNeeded.ts
-function supportsScrollIntoViewIfNeeded(element) {
-  return "scrollIntoViewIfNeeded" in element && typeof element.scrollIntoViewIfNeeded === "function";
-}
-function scrollIntoViewIfNeeded(el, centerIfNeeded = false) {
-  if (supportsScrollIntoViewIfNeeded(el)) {
-    el.scrollIntoViewIfNeeded(centerIfNeeded);
-    return;
-  }
+function scrollIntoViewIfNeeded(el, { block = "nearest", inline = "nearest" } = {}) {
   if (!isHTMLElement(el)) {
-    return el.scrollIntoView();
-  }
-  var parent = getFirstScrollableAncestor(el);
-  if (!isHTMLElement(parent)) {
     return;
   }
-  const parentComputedStyle = getComputedStyles(parent, true), parentBorderTopWidth = parseInt(
-    parentComputedStyle.getPropertyValue("border-top-width")
-  ), parentBorderLeftWidth = parseInt(
-    parentComputedStyle.getPropertyValue("border-left-width")
-  ), overTop = el.offsetTop - parent.offsetTop < parent.scrollTop, overBottom = el.offsetTop - parent.offsetTop + el.clientHeight - parentBorderTopWidth > parent.scrollTop + parent.clientHeight, overLeft = el.offsetLeft - parent.offsetLeft < parent.scrollLeft, overRight = el.offsetLeft - parent.offsetLeft + el.clientWidth - parentBorderLeftWidth > parent.scrollLeft + parent.clientWidth, alignWithTop = overTop && !overBottom;
-  if ((overTop || overBottom) && centerIfNeeded) {
-    parent.scrollTop = el.offsetTop - parent.offsetTop - parent.clientHeight / 2 - parentBorderTopWidth + el.clientHeight / 2;
-  }
-  if ((overLeft || overRight) && centerIfNeeded) {
-    parent.scrollLeft = el.offsetLeft - parent.offsetLeft - parent.clientWidth / 2 - parentBorderLeftWidth + el.clientWidth / 2;
+  const scrollableAncestors = getScrollableAncestors(el);
+  const processedAncestors = [];
+  for (const ancestor of scrollableAncestors) {
+    if (!isHTMLElement(ancestor)) {
+      continue;
+    }
+    const { top, left } = getOffsetRelativeTo(el, ancestor);
+    let adjustedTop = top;
+    let adjustedLeft = left;
+    for (const inner of processedAncestors) {
+      adjustedTop -= inner.scrollTop;
+      adjustedLeft -= inner.scrollLeft;
+    }
+    if (block !== "none") {
+      const overTop = adjustedTop < ancestor.scrollTop;
+      const overBottom = adjustedTop + el.offsetHeight > ancestor.scrollTop + ancestor.clientHeight;
+      if (overTop !== overBottom) {
+        if (block === "center") {
+          ancestor.scrollTop = adjustedTop - ancestor.clientHeight / 2 + el.offsetHeight / 2;
+        } else if (overTop) {
+          ancestor.scrollTop = adjustedTop;
+        } else {
+          ancestor.scrollTop = adjustedTop + el.offsetHeight - ancestor.clientHeight;
+        }
+      }
+    }
+    if (inline !== "none") {
+      const overLeft = adjustedLeft < ancestor.scrollLeft;
+      const overRight = adjustedLeft + el.offsetWidth > ancestor.scrollLeft + ancestor.clientWidth;
+      if (overLeft !== overRight) {
+        if (inline === "center") {
+          ancestor.scrollLeft = adjustedLeft - ancestor.clientWidth / 2 + el.offsetWidth / 2;
+        } else if (overLeft) {
+          ancestor.scrollLeft = adjustedLeft;
+        } else {
+          ancestor.scrollLeft = adjustedLeft + el.offsetWidth - ancestor.clientWidth;
+        }
+      }
+    }
+    processedAncestors.push(ancestor);
   }
-  if ((overTop || overBottom || overLeft || overRight) && !centerIfNeeded) {
-    el.scrollIntoView(alignWithTop);
+}
+function getDocumentOffset(element) {
+  let top = 0;
+  let left = 0;
+  let current = element;
+  while (current) {
+    top += current.offsetTop;
+    left += current.offsetLeft;
+    const offsetParent = current.offsetParent;
+    if (!isHTMLElement(offsetParent)) {
+      break;
+    }
+    top += offsetParent.clientTop;
+    left += offsetParent.clientLeft;
+    current = offsetParent;
   }
+  return { top, left };
+}
+function getOffsetRelativeTo(element, ancestor) {
+  const elOffset = getDocumentOffset(element);
+  const ancestorOffset = getDocumentOffset(ancestor);
+  return {
+    top: elOffset.top - ancestorOffset.top - ancestor.clientTop,
+    left: elOffset.left - ancestorOffset.left - ancestor.clientLeft
+  };
 }
 
 // src/utilities/transform/applyTransform.ts
@@ -1232,34 +1383,37 @@ var DOMRectangle = class extends Rectangle {
   }
 };
 function getProjectedTransform(element, computedStyles) {
-  var _a;
   const animations2 = element.getAnimations();
-  let projectedTransform = null;
   if (!animations2.length) return null;
+  let latestTransform;
+  let latestTranslate;
+  let latestScale;
+  let hasAnimatedProperty = false;
   for (const animation of animations2) {
     if (animation.playState !== "running") continue;
     const keyframes = isKeyframeEffect(animation.effect) ? animation.effect.getKeyframes() : [];
     const keyframe = keyframes[keyframes.length - 1];
     if (!keyframe) continue;
     const { transform, translate, scale } = keyframe;
-    if (transform || translate || scale) {
-      const parsedTransform = parseTransform({
-        transform: typeof transform === "string" && transform ? transform : computedStyles.transform,
-        translate: typeof translate === "string" && translate ? translate : computedStyles.translate,
-        scale: typeof scale === "string" && scale ? scale : computedStyles.scale
-      });
-      if (parsedTransform) {
-        projectedTransform = projectedTransform ? {
-          x: projectedTransform.x + parsedTransform.x,
-          y: projectedTransform.y + parsedTransform.y,
-          z: (_a = projectedTransform.z) != null ? _a : parsedTransform.z,
-          scaleX: projectedTransform.scaleX * parsedTransform.scaleX,
-          scaleY: projectedTransform.scaleY * parsedTransform.scaleY
-        } : parsedTransform;
-      }
+    if (typeof transform === "string" && transform) {
+      latestTransform = transform;
+      hasAnimatedProperty = true;
+    }
+    if (typeof translate === "string" && translate) {
+      latestTranslate = translate;
+      hasAnimatedProperty = true;
+    }
+    if (typeof scale === "string" && scale) {
+      latestScale = scale;
+      hasAnimatedProperty = true;
     }
   }
-  return projectedTransform;
+  if (!hasAnimatedProperty) return null;
+  return parseTransform({
+    transform: latestTransform != null ? latestTransform : computedStyles.transform,
+    translate: latestTranslate != null ? latestTranslate : computedStyles.translate,
+    scale: latestScale != null ? latestScale : computedStyles.scale
+  });
 }
 
 // src/utilities/type-guards/supportsStyle.ts
@@ -1356,6 +1510,6 @@ function generateUniqueId(prefix) {
   return `${prefix}-${id}`;
 }
 
-export { DOMRectangle, Listeners, FrameObserver as PositionObserver, ProxiedElements, ResizeNotifier, Scheduler, ScrollDirection, Styles, animateTransform, canScroll, canUseDOM, cloneElement, computeTranslate, detectScrollIntent, generateUniqueId, getBoundingRectangle, getComputedStyles, getDocument, getElementFromPoint, getFinalKeyframe, getFirstScrollableAncestor, getFrameElement, getFrameTransform, getScrollableAncestors, getViewportBoundingRectangle, getVisibleBoundingRectangle, getWindow, hidePopover, inverseTransform, isDocumentScrollingElement, isElement, isHTMLElement, isKeyboardEvent, isKeyframeEffect, isPointerEvent, isSafari, isTextInput, parseTransform, parseTranslate, scheduler, scrollIntoViewIfNeeded, showPopover, supportsPopover, supportsStyle, supportsViewTransition, timeout };
+export { DOMRectangle, Listeners, FrameObserver as PositionObserver, ProxiedElements, ResizeNotifier, Scheduler, ScrollDirection, Styles, animateTransform, canScroll, canUseDOM, cloneElement, computeTranslate, detectScrollIntent, generateUniqueId, getBoundingRectangle, getComputedStyles, getDocument, getDocuments, getElementFromPoint, getEventCoordinates, getFinalKeyframe, getFirstScrollableAncestor, getFixedPositionOffset, getFrameElement, getFrameTransform, getInteractiveElement, getRoot, getScrollPosition, getScrollableAncestors, getViewportBoundingRectangle, getVisibleBoundingRectangle, getWindow, hidePopover, inverseTransform, isDocument, isDocumentScrollingElement, isElement, isHTMLElement, isInteractiveElement, isKeyboardEvent, isKeyframeEffect, isPointerEvent, isSafari, isShadowRoot, isTextInput, parseTransform, parseTranslate, prefersReducedMotion, scheduler, scrollIntoViewIfNeeded, showPopover, supportsPopover, supportsStyle, supportsViewTransition, timeout };
 //# sourceMappingURL=utilities.js.map
 //# sourceMappingURL=utilities.js.map