@tamagui/use-element-layout 2.0.0-rc.4 → 2.0.0-rc.40

package/dist/cjs/index.native.js

@@ -5,20 +5,22 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: !0
+  value: true
 }), mod);
 var index_exports = {};
 __export(index_exports, {
@@ -33,242 +35,399 @@ __export(index_exports, {
   measureInWindow: () => measureInWindow,
   measureLayout: () => measureLayout,
   measureNode: () => measureNode,
+  registerLayoutNode: () => registerLayoutNode,
   setOnLayoutStrategy: () => setOnLayoutStrategy,
   useElementLayout: () => useElementLayout
 });
 module.exports = __toCommonJS(index_exports);
-var import_jsx_runtime = require("react/jsx-runtime"),
-  import_constants = require("@tamagui/constants"),
-  import_is_equal_shallow = require("@tamagui/is-equal-shallow"),
-  import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_constants = require("@tamagui/constants");
+var import_react = require("react");
 function _instanceof(left, right) {
-  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);else return left instanceof right;
 }
-var LayoutHandlers = /* @__PURE__ */new WeakMap(),
-  LayoutDisableKey = /* @__PURE__ */new WeakMap(),
-  Nodes = /* @__PURE__ */new Set(),
-  IntersectionState = /* @__PURE__ */new WeakMap(),
-  DisableLayoutContextValues = {},
-  DisableLayoutContextKey = /* @__PURE__ */(0, import_react.createContext)(""),
-  ENABLE = !1,
-  LayoutMeasurementController = function (param) {
-    var {
-        disable,
-        children
-      } = param,
-      id = (0, import_react.useId)();
-    return (0, import_constants.useIsomorphicLayoutEffect)(function () {
-      DisableLayoutContextValues[id] = disable;
-    }, [disable, id]), /* @__PURE__ */(0, import_jsx_runtime.jsx)(DisableLayoutContextKey.Provider, {
-      value: id,
-      children
-    });
-  },
-  globalIntersectionObserver = null,
-  strategy = "async";
+var LayoutHandlers = /* @__PURE__ */new WeakMap();
+var LayoutDisableKey = /* @__PURE__ */new WeakMap();
+var Nodes = /* @__PURE__ */new Set();
+var IntersectionState = /* @__PURE__ */new WeakMap();
+var usePretransformDimensions = function () {
+  return globalThis.__TAMAGUI_ONLAYOUT_PRETRANSFORM === true || process.env.TAMAGUI_ONLAYOUT_PRETRANSFORM === "1";
+};
+var _debugLayout;
+function isDebugLayout() {
+  if (_debugLayout === void 0) _debugLayout = typeof window !== "undefined" && new URLSearchParams(window.location.search).has("__tamaDebugLayout");
+  return _debugLayout;
+}
+var DisableLayoutContextValues = {};
+var DisableLayoutContextKey = /* @__PURE__ */(0, import_react.createContext)("");
+var ENABLE = false;
+var LayoutMeasurementController = function (param) {
+  var {
+    disable,
+    children
+  } = param;
+  var id = (0, import_react.useId)();
+  (0, import_constants.useIsomorphicLayoutEffect)(function () {
+    DisableLayoutContextValues[id] = disable;
+  }, [disable, id]);
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(DisableLayoutContextKey.Provider, {
+    value: id,
+    children
+  });
+};
+var globalIntersectionObserver = null;
+var strategy = "async";
 function setOnLayoutStrategy(state) {
   strategy = state;
 }
-var NodeRectCache = /* @__PURE__ */new WeakMap(),
-  LastChangeTime = /* @__PURE__ */new WeakMap(),
-  avoidUpdates = !0,
-  queuedUpdates = /* @__PURE__ */new Map();
+var NodeRectCache = /* @__PURE__ */new WeakMap();
+var avoidUpdates = true;
+var queuedUpdates = /* @__PURE__ */new Map();
 function enable() {
-  avoidUpdates && (avoidUpdates = !1, queuedUpdates && (queuedUpdates.forEach(function (cb) {
-    return cb();
-  }), queuedUpdates.clear()));
+  if (avoidUpdates) {
+    avoidUpdates = false;
+    if (queuedUpdates) {
+      queuedUpdates.forEach(function (cb) {
+        return cb();
+      });
+      queuedUpdates.clear();
+    }
+  }
 }
 function startGlobalObservers() {
-  !ENABLE || globalIntersectionObserver || (globalIntersectionObserver = new IntersectionObserver(function (entries) {
-    entries.forEach(function (entry) {
+  if (!ENABLE || globalIntersectionObserver) return;
+  globalIntersectionObserver = new IntersectionObserver(function (entries) {
+    for (var i = 0; i < entries.length; i++) {
+      var entry = entries[i];
       var node = entry.target;
-      IntersectionState.get(node) !== entry.isIntersecting && IntersectionState.set(node, entry.isIntersecting);
-    });
+      if (IntersectionState.get(node) !== entry.isIntersecting) IntersectionState.set(node, entry.isIntersecting);
+    }
   }, {
     threshold: 0
-  }));
+  });
+}
+function rectsEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
 }
 if (ENABLE) {
+  let ensureRectFetchObserver = function () {
+    if (rectFetchObserver) return rectFetchObserver;
+    rectFetchObserver = new IntersectionObserver(function (entries) {
+      lastCallbackDelay = Math.round(performance.now() - rectFetchStartTime);
+      for (var i = 0; i < entries.length; i++) BoundingRects.set(entries[i].target, entries[i].boundingClientRect);
+      if (process.env.NODE_ENV === "development" && isDebugLayout() && lastCallbackDelay > 50) console.warn("[onLayout-io-delay]", lastCallbackDelay + "ms", entries.length, "entries");
+      if (rectFetchResolve) {
+        rectFetchResolve(true);
+        rectFetchResolve = null;
+      }
+    }, {
+      threshold: 0
+    });
+    return rectFetchObserver;
+  };
   var BoundingRects = /* @__PURE__ */new WeakMap();
+  var rectFetchObserver = null;
+  var rectFetchResolve = null;
+  var rectFetchStartTime = 0;
+  var lastCallbackDelay = 0;
   async function updateLayoutIfChanged(node) {
     var onLayout = LayoutHandlers.get(node);
-    if (typeof onLayout == "function") {
-      var parentNode = node.parentElement;
-      if (parentNode) {
-        var nodeRect, parentRect;
-        if (strategy === "async") {
-          var [nr, pr] = await Promise.all([BoundingRects.get(node), BoundingRects.get(parentNode)]);
-          if (!nr || !pr) return;
-          nodeRect = nr, parentRect = pr;
-        } else nodeRect = node.getBoundingClientRect(), parentRect = parentNode.getBoundingClientRect();
-        if (!(!nodeRect || !parentRect)) {
-          var cachedRect = NodeRectCache.get(node),
-            cachedParentRect = NodeRectCache.get(parentNode);
-          if (!cachedRect || !cachedParentRect ||
-          // has changed one rect
-          // @ts-expect-error DOMRectReadOnly can go into object
-          !(0, import_is_equal_shallow.isEqualShallow)(cachedRect, nodeRect) ||
-          // @ts-expect-error DOMRectReadOnly can go into object
-          !(0, import_is_equal_shallow.isEqualShallow)(cachedParentRect, parentRect)) {
-            NodeRectCache.set(node, nodeRect), NodeRectCache.set(parentNode, parentRect);
-            var event = getElementLayoutEvent(nodeRect, parentRect);
-            avoidUpdates ? queuedUpdates.set(node, function () {
-              return onLayout(event);
-            }) : onLayout(event);
-          }
-        }
-      }
+    if (typeof onLayout !== "function") return;
+    var parentNode = node.parentElement;
+    if (!parentNode) return;
+    var nodeRect;
+    var parentRect;
+    if (strategy === "async") {
+      nodeRect = BoundingRects.get(node);
+      parentRect = BoundingRects.get(parentNode);
+      if (!nodeRect || !parentRect) return;
+    } else {
+      nodeRect = node.getBoundingClientRect();
+      parentRect = parentNode.getBoundingClientRect();
+    }
+    var cachedRect = NodeRectCache.get(node);
+    var cachedParentRect = NodeRectCache.get(parentNode);
+    var nodeChanged = !cachedRect || !rectsEqual(cachedRect, nodeRect);
+    var parentChanged = !cachedParentRect || !rectsEqual(cachedParentRect, parentRect);
+    if (nodeChanged || parentChanged) {
+      NodeRectCache.set(node, nodeRect);
+      NodeRectCache.set(parentNode, parentRect);
+      var event = getElementLayoutEvent(nodeRect, parentRect, node);
+      if (process.env.NODE_ENV === "development" && isDebugLayout()) console.log("[useElementLayout] change", {
+        tag: node.tagName,
+        id: node.id || void 0,
+        className: (node.className || "").slice(0, 60) || void 0,
+        layout: event.nativeEvent.layout,
+        first: !cachedRect
+      });
+      if (avoidUpdates) queuedUpdates.set(node, function () {
+        return onLayout(event);
+      });else onLayout(event);
     }
   }
-  var userSkipVal = process.env.TAMAGUI_LAYOUT_FRAME_SKIP,
-    RUN_EVERY_X_FRAMES = userSkipVal ? +userSkipVal : 14;
+  var rAF = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : void 0;
+  var userSkipVal = process.env.TAMAGUI_LAYOUT_FRAME_SKIP;
+  var BASE_SKIP_FRAMES = userSkipVal ? +userSkipVal : 10;
+  var MAX_SKIP_FRAMES = 20;
+  var skipFrames = BASE_SKIP_FRAMES;
+  var frameCount = 0;
   async function layoutOnAnimationFrame() {
+    if (frameCount++ % skipFrames !== 0) {
+      rAF ? rAF(layoutOnAnimationFrame) : setTimeout(layoutOnAnimationFrame, 16);
+      return;
+    }
+    if (frameCount >= Number.MAX_SAFE_INTEGER) frameCount = 0;
     if (strategy !== "off") {
-      var visibleNodes = [],
-        didRun = await new Promise(function (res) {
-          var io = new IntersectionObserver(function (entries) {
-              io.disconnect();
-              var _iteratorNormalCompletion2 = !0,
-                _didIteratorError2 = !1,
-                _iteratorError2 = void 0;
-              try {
-                for (var _iterator2 = entries[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
-                  var entry = _step2.value;
-                  BoundingRects.set(entry.target, entry.boundingClientRect);
-                }
-              } catch (err) {
-                _didIteratorError2 = !0, _iteratorError2 = err;
-              } finally {
-                try {
-                  !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
-                } finally {
-                  if (_didIteratorError2) throw _iteratorError2;
-                }
-              }
-              res(!0);
-            }, {
-              threshold: 0
-            }),
-            didObserve = !1,
-            _iteratorNormalCompletion = !0,
-            _didIteratorError = !1,
-            _iteratorError = void 0;
+      var visibleNodes = [];
+      var parentsToObserve = /* @__PURE__ */new Set();
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = Nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var node = _step.value;
+          var parentElement = node.parentElement;
+          if (!_instanceof(parentElement, HTMLElement)) {
+            cleanupNode(node);
+            continue;
+          }
+          var disableKey = LayoutDisableKey.get(node);
+          if (disableKey && DisableLayoutContextValues[disableKey] === true) continue;
+          if (IntersectionState.get(node) === false) continue;
+          visibleNodes.push(node);
+          parentsToObserve.add(parentElement);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+        } finally {
+          if (_didIteratorError) throw _iteratorError;
+        }
+      }
+      if (visibleNodes.length > 0) {
+        var io = ensureRectFetchObserver();
+        rectFetchStartTime = performance.now();
+        for (var i = 0; i < visibleNodes.length; i++) io.observe(visibleNodes[i]);
+        var _iteratorNormalCompletion1 = true,
+          _didIteratorError1 = false,
+          _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = parentsToObserve[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var parent = _step1.value;
+            io.observe(parent);
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
           try {
-            for (var _iterator = Nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
-              var node = _step.value;
-              if (_instanceof(node.parentElement, HTMLElement)) {
-                var disableKey = LayoutDisableKey.get(node);
-                disableKey && DisableLayoutContextValues[disableKey] === !0 || IntersectionState.get(node) !== !1 && (didObserve = !0, io.observe(node), io.observe(node.parentElement), visibleNodes.push(node));
-              }
-            }
-          } catch (err) {
-            _didIteratorError = !0, _iteratorError = err;
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) _iterator1.return();
           } finally {
-            try {
-              !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
-            } finally {
-              if (_didIteratorError) throw _iteratorError;
-            }
+            if (_didIteratorError1) throw _iteratorError1;
           }
-          didObserve || res(!1);
+        }
+        await new Promise(function (res) {
+          rectFetchResolve = res;
         });
-      didRun && visibleNodes.forEach(function (node) {
-        updateLayoutIfChanged(node);
-      });
+        for (var i1 = 0; i1 < visibleNodes.length; i1++) io.unobserve(visibleNodes[i1]);
+        var _iteratorNormalCompletion2 = true,
+          _didIteratorError2 = false,
+          _iteratorError2 = void 0;
+        try {
+          for (var _iterator2 = parentsToObserve[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var parent1 = _step2.value;
+            io.unobserve(parent1);
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) _iterator2.return();
+          } finally {
+            if (_didIteratorError2) throw _iteratorError2;
+          }
+        }
+        if (lastCallbackDelay > 50) skipFrames = Math.min(skipFrames + 2, MAX_SKIP_FRAMES);else if (lastCallbackDelay < 20) skipFrames = Math.max(skipFrames - 1, BASE_SKIP_FRAMES);
+        for (var i2 = 0; i2 < visibleNodes.length; i2++) updateLayoutIfChanged(visibleNodes[i2]);
+      }
     }
-    setTimeout(layoutOnAnimationFrame, 16.6667 * RUN_EVERY_X_FRAMES);
+    rAF ? rAF(layoutOnAnimationFrame) : setTimeout(layoutOnAnimationFrame, 16);
   }
   layoutOnAnimationFrame();
 }
-var getElementLayoutEvent = function (nodeRect, parentRect) {
-    return {
-      nativeEvent: {
-        layout: getRelativeDimensions(nodeRect, parentRect),
-        target: nodeRect
-      },
-      timeStamp: Date.now()
-    };
-  },
-  getRelativeDimensions = function (a, b) {
-    var {
-        height,
-        left,
-        top,
-        width
-      } = a,
-      x = left - b.left,
-      y = top - b.top;
-    return {
-      x,
-      y,
-      width,
-      height,
-      pageX: a.left,
-      pageY: a.top
-    };
+var getElementLayoutEvent = function (nodeRect, parentRect, node) {
+  return {
+    nativeEvent: {
+      layout: getRelativeDimensions(nodeRect, parentRect, node),
+      target: nodeRect
+    },
+    timeStamp: Date.now()
+  };
+};
+var getPreTransformDimensions = function (node) {
+  return {
+    width: node.offsetWidth,
+    height: node.offsetHeight
+  };
+};
+var getRelativeDimensions = function (a, b, aNode) {
+  var {
+    left,
+    top
+  } = a;
+  var x = left - b.left;
+  var y = top - b.top;
+  var {
+    width,
+    height
+  } = usePretransformDimensions() && aNode ? getPreTransformDimensions(aNode) : {
+    width: a.width,
+    height: a.height
+  };
+  return {
+    x,
+    y,
+    width,
+    height,
+    pageX: a.left,
+    pageY: a.top
   };
+};
+function registerLayoutNode(node, onChange, disableKey) {
+  Nodes.add(node);
+  LayoutHandlers.set(node, onChange);
+  if (disableKey) LayoutDisableKey.set(node, disableKey);
+  startGlobalObservers();
+  if (globalIntersectionObserver) {
+    globalIntersectionObserver.observe(node);
+    IntersectionState.set(node, true);
+  }
+  return function () {
+    return cleanupNode(node);
+  };
+}
+function cleanupNode(node) {
+  Nodes.delete(node);
+  LayoutHandlers.delete(node);
+  LayoutDisableKey.delete(node);
+  NodeRectCache.delete(node);
+  IntersectionState.delete(node);
+  if (globalIntersectionObserver) globalIntersectionObserver.unobserve(node);
+}
+var PrevHostNode = /* @__PURE__ */new WeakMap();
 function useElementLayout(ref, onLayout) {
-  var _ref_current,
-    disableKey = (0, import_react.useContext)(DisableLayoutContextKey),
-    node = ensureWebElement((_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.host);
-  node && onLayout && (LayoutHandlers.set(node, onLayout), LayoutDisableKey.set(node, disableKey)), (0, import_constants.useIsomorphicLayoutEffect)(function () {
+  var _ref_current;
+  var disableKey = (0, import_react.useContext)(DisableLayoutContextKey);
+  var node = ensureWebElement((_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.host);
+  if (node && onLayout) {
+    LayoutHandlers.set(node, onLayout);
+    LayoutDisableKey.set(node, disableKey);
+  }
+  (0, import_constants.useIsomorphicLayoutEffect)(function () {
     var _ref_current2;
-    if (onLayout) {
-      var node2 = (_ref_current2 = ref.current) === null || _ref_current2 === void 0 ? void 0 : _ref_current2.host;
-      if (node2) {
-        Nodes.add(node2), startGlobalObservers(), globalIntersectionObserver && (globalIntersectionObserver.observe(node2), IntersectionState.set(node2, !0));
-        var parentNode = node2.parentNode;
-        return parentNode && onLayout(getElementLayoutEvent(node2.getBoundingClientRect(), parentNode.getBoundingClientRect())), function () {
-          Nodes.delete(node2), LayoutHandlers.delete(node2), NodeRectCache.delete(node2), LastChangeTime.delete(node2), IntersectionState.delete(node2), globalIntersectionObserver && globalIntersectionObserver.unobserve(node2);
-        };
-      }
+    if (!onLayout) return;
+    var nextNode = ensureWebElement((_ref_current2 = ref.current) === null || _ref_current2 === void 0 ? void 0 : _ref_current2.host);
+    var prevNode = PrevHostNode.get(ref);
+    if (nextNode === prevNode) return;
+    if (prevNode) cleanupNode(prevNode);
+    PrevHostNode.set(ref, nextNode);
+    if (!nextNode) return;
+    Nodes.add(nextNode);
+    startGlobalObservers();
+    if (globalIntersectionObserver) {
+      globalIntersectionObserver.observe(nextNode);
+      IntersectionState.set(nextNode, true);
     }
+    var handler = LayoutHandlers.get(nextNode);
+    if (typeof handler !== "function") return;
+    var parentNode = nextNode.parentElement;
+    if (!parentNode) return;
+    var nodeRect = nextNode.getBoundingClientRect();
+    var parentRect = parentNode.getBoundingClientRect();
+    NodeRectCache.set(nextNode, nodeRect);
+    NodeRectCache.set(parentNode, parentRect);
+    handler(getElementLayoutEvent(nodeRect, parentRect, nextNode));
+  });
+  (0, import_constants.useIsomorphicLayoutEffect)(function () {
+    var _ref_current2;
+    if (!onLayout) return;
+    var node2 = (_ref_current2 = ref.current) === null || _ref_current2 === void 0 ? void 0 : _ref_current2.host;
+    if (!node2) return;
+    Nodes.add(node2);
+    startGlobalObservers();
+    if (globalIntersectionObserver) {
+      globalIntersectionObserver.observe(node2);
+      IntersectionState.set(node2, true);
+    }
+    if (process.env.NODE_ENV === "development" && isDebugLayout()) console.log("[useElementLayout] register", {
+      tag: node2.tagName,
+      id: node2.id || void 0,
+      className: (node2.className || "").slice(0, 60) || void 0,
+      totalNodes: Nodes.size
+    });
+    var parentNode = node2.parentNode;
+    if (parentNode) onLayout(getElementLayoutEvent(node2.getBoundingClientRect(), parentNode.getBoundingClientRect(), node2));
+    return function () {
+      cleanupNode(node2);
+      var swappedNode = PrevHostNode.get(ref);
+      if (swappedNode && swappedNode !== node2) cleanupNode(swappedNode);
+      PrevHostNode.delete(ref);
+    };
   }, [ref, !!onLayout]);
 }
 function ensureWebElement(x) {
-  if (!(typeof HTMLElement > "u")) return _instanceof(x, HTMLElement) ? x : void 0;
+  if (typeof HTMLElement === "undefined") return;
+  return _instanceof(x, HTMLElement) ? x : void 0;
 }
 var getBoundingClientRectAsync = function (node) {
-    return new Promise(function (res) {
-      if (!node || node.nodeType !== 1) return res(!1);
-      var io = new IntersectionObserver(function (entries) {
-        return io.disconnect(), res(entries[0].boundingClientRect);
-      }, {
-        threshold: 0
-      });
-      io.observe(node);
+  return new Promise(function (res) {
+    if (!node || node.nodeType !== 1) return res(false);
+    var io = new IntersectionObserver(function (entries) {
+      io.disconnect();
+      return res(entries[0].boundingClientRect);
+    }, {
+      threshold: 0
     });
-  },
-  measureNode = async function (node, relativeTo) {
-    var relativeNode = relativeTo || node?.parentElement;
-    if (_instanceof(relativeNode, HTMLElement)) {
-      var [nodeDim, relativeNodeDim] = await Promise.all([getBoundingClientRectAsync(node), getBoundingClientRectAsync(relativeNode)]);
-      if (relativeNodeDim && nodeDim) return getRelativeDimensions(nodeDim, relativeNodeDim);
-    }
-    return null;
-  },
-  measure = async function (node, callback) {
-    var out = await measureNode(node, _instanceof(node.parentNode, HTMLElement) ? node.parentNode : null);
-    return out && callback?.(out.x, out.y, out.width, out.height, out.pageX, out.pageY), out;
-  };
+    io.observe(node);
+  });
+};
+var measureNode = async function (node, relativeTo) {
+  var relativeNode = relativeTo || (node === null || node === void 0 ? void 0 : node.parentElement);
+  if (_instanceof(relativeNode, HTMLElement)) {
+    var [nodeDim, relativeNodeDim] = await Promise.all([getBoundingClientRectAsync(node), getBoundingClientRectAsync(relativeNode)]);
+    if (relativeNodeDim && nodeDim) return getRelativeDimensions(nodeDim, relativeNodeDim, node);
+  }
+  return null;
+};
+var measure = async function (node, callback) {
+  var out = await measureNode(node, _instanceof(node.parentNode, HTMLElement) ? node.parentNode : null);
+  if (out) callback === null || callback === void 0 || callback(out.x, out.y, out.width, out.height, out.pageX, out.pageY);
+  return out;
+};
 function createMeasure(node) {
   return function (callback) {
     return measure(node, callback);
   };
 }
 var measureInWindow = async function (node, callback) {
-    var out = await measureNode(node, null);
-    return out && callback?.(out.pageX, out.pageY, out.width, out.height), out;
-  },
-  createMeasureInWindow = function (node) {
-    return function (callback) {
-      return measureInWindow(node, callback);
-    };
-  },
-  measureLayout = async function (node, relativeNode, callback) {
-    var out = await measureNode(node, relativeNode);
-    return out && callback?.(out.x, out.y, out.width, out.height, out.pageX, out.pageY), out;
+  var out = await measureNode(node, null);
+  if (out) callback === null || callback === void 0 || callback(out.pageX, out.pageY, out.width, out.height);
+  return out;
+};
+var createMeasureInWindow = function (node) {
+  return function (callback) {
+    return measureInWindow(node, callback);
   };
+};
+var measureLayout = async function (node, relativeNode, callback) {
+  var out = await measureNode(node, relativeNode);
+  if (out) callback === null || callback === void 0 || callback(out.x, out.y, out.width, out.height, out.pageX, out.pageY);
+  return out;
+};
 function createMeasureLayout(node) {
   return function (relativeTo, callback) {
     return measureLayout(node, relativeTo, callback);