@lark-apaas/miaoda-inspector 0.1.0-alpha.1

package/dist/lib/Inspector/Overlay.js

@@ -0,0 +1,419 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  Overlay: function() {
+    return Overlay;
+  },
+  ClickOverlay: function() {
+    return ClickOverlay;
+  }
+});
+const _utils = require("./utils");
+const overlayStyles = {
+  padding: "transparent",
+  margin: "transparent",
+  border: "transparent"
+};
+function boxWrap(dims, what, node) {
+  Object.assign(node.style, {
+    borderTopWidth: `${dims[`${what}Top`]}px`,
+    borderLeftWidth: `${dims[`${what}Left`]}px`,
+    borderRightWidth: `${dims[`${what}Right`]}px`,
+    borderBottomWidth: `${dims[`${what}Bottom`]}px`,
+    borderStyle: "solid"
+  });
+}
+function findTipPos(dims, bounds, tipSize) {
+  const tipHeight = Math.max(tipSize.height, 20);
+  const tipWidth = Math.max(tipSize.width, 60);
+  const margin = 4;
+  let top;
+  if (dims.top - tipHeight - margin >= bounds.top) {
+    top = dims.top - tipHeight - margin;
+  } else if (dims.top + dims.height + tipHeight <= bounds.top + bounds.height) {
+    if (dims.top + dims.height < bounds.top + 0) {
+      top = bounds.top + margin;
+    } else {
+      top = dims.top + dims.height + margin;
+    }
+  } else if (dims.top - tipHeight <= bounds.top + bounds.height) {
+    if (dims.top - tipHeight - margin < bounds.top + margin) {
+      top = bounds.top + margin;
+    } else {
+      top = dims.top - tipHeight - margin;
+    }
+  } else {
+    top = bounds.top + bounds.height - tipHeight - margin;
+  }
+  let { left } = dims;
+  if (dims.left < bounds.left) {
+    left = bounds.left;
+  }
+  if (dims.left + tipWidth > bounds.left + bounds.width) {
+    left = bounds.left + bounds.width - tipWidth;
+  }
+  return {
+    style: {
+      top: `${top}px`,
+      // 目前 box 的样式是设置的 outline，为了对齐要向左偏移 1px
+      left: `${left - 1}px`
+    }
+  };
+}
+class OverlayRect {
+  remove() {
+    if (this.node.parentNode) {
+      this.node.parentNode.removeChild(this.node);
+    }
+  }
+  update(box, dims) {
+    boxWrap(dims, "margin", this.node);
+    boxWrap(dims, "border", this.border);
+    boxWrap(dims, "padding", this.padding);
+    Object.assign(this.content.style, {
+      height: `${box.height - dims.borderTop - dims.borderBottom - dims.paddingTop - dims.paddingBottom}px`,
+      width: `${box.width - dims.borderLeft - dims.borderRight - dims.paddingLeft - dims.paddingRight}px`
+    });
+    Object.assign(this.node.style, {
+      top: `${box.top - dims.marginTop}px`,
+      left: `${box.left - dims.marginLeft}px`
+    });
+  }
+  constructor(doc, container) {
+    this.node = doc.createElement("div");
+    this.border = doc.createElement("div");
+    this.padding = doc.createElement("div");
+    this.content = doc.createElement("div");
+    this.border.style.borderColor = overlayStyles.border;
+    this.padding.style.borderColor = overlayStyles.padding;
+    Object.assign(this.node.style, {
+      borderColor: overlayStyles.margin,
+      pointerEvents: "none",
+      position: "fixed",
+      outline: "1px dashed #1456f0"
+    });
+    this.node.style.zIndex = "10000000";
+    this.node.appendChild(this.border);
+    this.border.appendChild(this.padding);
+    this.padding.appendChild(this.content);
+    container.prepend(this.node);
+  }
+}
+class ClickOverlayRect {
+  remove() {
+    if (this.node.parentNode) {
+      this.node.parentNode.removeChild(this.node);
+    }
+  }
+  update(box, dims) {
+    Object.assign(this.node.style, {
+      top: `${box.top - 1 - dims.marginTop}px`,
+      left: `${box.left - 1 - dims.marginLeft}px`,
+      width: `${box.width + dims.marginLeft + dims.marginRight + 2}px`,
+      height: `${box.height + dims.marginTop + dims.marginBottom + 2}px`
+    });
+  }
+  constructor(doc, container) {
+    this.node = doc.createElement("div");
+    this.border = doc.createElement("div");
+    Object.assign(this.border.style, {
+      pointerEvents: "none",
+      position: "absolute",
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      boxSizing: "border-box",
+      border: "1px solid #1456f0"
+    });
+    Object.assign(this.node.style, {
+      pointerEvents: "none",
+      position: "fixed",
+      zIndex: "9999999"
+    });
+    this.node.appendChild(this.border);
+    container.appendChild(this.node);
+  }
+}
+class OverlayTip {
+  remove() {
+    if (this.tip.parentNode) {
+      this.tip.parentNode.removeChild(this.tip);
+    }
+  }
+  updateText(name) {
+    this.titleDiv.textContent = name;
+  }
+  updatePosition(dims, bounds) {
+    const tipRect = this.tip.getBoundingClientRect();
+    const tipPos = findTipPos(dims, bounds, {
+      width: tipRect.width,
+      height: tipRect.height
+    });
+    Object.assign(this.tip.style, tipPos.style);
+    if (dims.width === 0 || dims.height === 0) {
+      this.invisible();
+    } else {
+      Object.assign(this.tip.style, {
+        display: "flex"
+      });
+    }
+  }
+  invisible() {
+    Object.assign(this.tip.style, {
+      display: "none"
+    });
+  }
+  constructor(doc, container) {
+    this.tip = doc.createElement("div");
+    Object.assign(this.tip.style, {
+      display: "flex",
+      flexFlow: "row nowrap",
+      alignItems: "center",
+      backgroundColor: "#1456f0",
+      borderRadius: "6px",
+      fontFamily: '"SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace',
+      fontWeight: "bold",
+      padding: "1px 12px",
+      pointerEvents: "none",
+      position: "fixed",
+      fontSize: "14px",
+      lineHeight: "22px",
+      whiteSpace: "nowrap"
+    });
+    this.nameSpan = doc.createElement("span");
+    this.tip.appendChild(this.nameSpan);
+    Object.assign(this.nameSpan.style, {
+      display: "flex",
+      flexDirection: "column"
+    });
+    this.titleDiv = doc.createElement("div");
+    this.nameSpan.appendChild(this.titleDiv);
+    Object.assign(this.titleDiv.style, {
+      color: "#fff",
+      fontSize: "14px",
+      borderRadius: "6px"
+    });
+    this.tip.style.zIndex = "10000000";
+    container.appendChild(this.tip);
+  }
+}
+class Overlay {
+  remove() {
+    this.tip.remove();
+    this.rects.forEach((rect) => {
+      rect.remove();
+    });
+    this.rects.length = 0;
+    if (this.container.parentNode) {
+      this.container.parentNode.removeChild(this.container);
+    }
+    this.removeCallback();
+  }
+  setRemoveCallback(callback) {
+    this.removeCallback = callback.bind(this);
+  }
+  inspect(nodes, name, info) {
+    this.resizeObserver.disconnect();
+    const elements = nodes.filter((node) => node.nodeType === Node.ELEMENT_NODE);
+    this.currentElements = nodes;
+    while (this.rects.length > elements.length) {
+      const rect = this.rects.pop();
+      rect === null || rect === void 0 ? void 0 : rect.remove();
+    }
+    if (elements.length === 0) {
+      return;
+    }
+    elements.forEach((element) => {
+      this.resizeObserver.observe(element);
+    });
+    this.updatePositions(elements, name, info);
+  }
+  updatePositions(nodes, name, info) {
+    const elements = nodes.filter((node) => node.nodeType === Node.ELEMENT_NODE);
+    while (this.rects.length > elements.length) {
+      const rect = this.rects.pop();
+      rect === null || rect === void 0 ? void 0 : rect.remove();
+    }
+    if (elements.length === 0) {
+      return;
+    }
+    while (this.rects.length < elements.length) {
+      this.rects.push(new OverlayRect(this.window.document, this.container));
+    }
+    const outerBox = {
+      top: Number.POSITIVE_INFINITY,
+      right: Number.NEGATIVE_INFINITY,
+      bottom: Number.NEGATIVE_INFINITY,
+      left: Number.POSITIVE_INFINITY
+    };
+    elements.forEach((element, index) => {
+      const box = (0, _utils.getNestedBoundingClientRect)(element, this.window);
+      const dims = (0, _utils.getElementDimensions)(element);
+      outerBox.top = Math.min(outerBox.top, box.top - dims.marginTop);
+      outerBox.right = Math.max(outerBox.right, box.left + box.width + dims.marginRight);
+      outerBox.bottom = Math.max(outerBox.bottom, box.top + box.height + dims.marginBottom);
+      outerBox.left = Math.min(outerBox.left, box.left - dims.marginLeft);
+      const rect = this.rects[index];
+      rect.update(box, dims);
+    });
+    if (!name) {
+      name = elements[0].nodeName.toLowerCase();
+    }
+    this.currentName = name;
+    if (this.handleCodeInfo) {
+      const [displayName] = this.handleCodeInfo(name || "", info);
+      this.tip.updateText(displayName);
+    } else {
+      this.tip.updateText(name);
+    }
+    const tipBounds = (0, _utils.getNestedBoundingClientRect)(this.tipBoundsWindow.document.documentElement, this.window);
+    this.tip.updatePosition({
+      top: outerBox.top,
+      left: outerBox.left,
+      height: outerBox.bottom - outerBox.top,
+      width: outerBox.right - outerBox.left
+    }, {
+      top: tipBounds.top + this.tipBoundsWindow.scrollY,
+      left: tipBounds.left + this.tipBoundsWindow.scrollX,
+      height: this.tipBoundsWindow.innerHeight,
+      width: this.tipBoundsWindow.innerWidth
+    });
+  }
+  clearRect() {
+    var _this_rects;
+    (_this_rects = this.rects) === null || _this_rects === void 0 ? void 0 : _this_rects.forEach((rect) => {
+      rect.remove();
+    });
+    this.rects.length = 0;
+    this.tip.invisible();
+  }
+  constructor(handleCodeInfo) {
+    this.handleCodeInfo = handleCodeInfo;
+    const currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+    this.window = currentWindow;
+    const tipBoundsWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+    this.tipBoundsWindow = tipBoundsWindow;
+    const doc = currentWindow.document;
+    this.container = doc.createElement("div");
+    this.container.style.zIndex = "10000000";
+    this.tip = new OverlayTip(doc, this.container);
+    this.rects = [];
+    this.removeCallback = () => {
+    };
+    let rafId = null;
+    this.resizeObserver = new ResizeObserver(() => {
+      if (rafId) {
+        cancelAnimationFrame(rafId);
+      }
+      rafId = requestAnimationFrame(() => {
+        if (this.currentElements && this.currentName) {
+          this.updatePositions(this.currentElements, this.currentName);
+        }
+      });
+    });
+    doc.body.appendChild(this.container);
+  }
+}
+class ClickOverlay {
+  remove() {
+    this.tip.remove();
+    if (this.rect) {
+      this.rect.remove();
+      this.rect = null;
+    }
+    this.currentElement = null;
+    this.resizeObserver.disconnect();
+    this.currentName = void 0;
+    if (this.container.parentNode) {
+      this.container.parentNode.removeChild(this.container);
+    }
+  }
+  highlight(element, name) {
+    if (!this.rect) {
+      this.rect = new ClickOverlayRect(this.window.document, this.container);
+    }
+    this.resizeObserver.disconnect();
+    this.currentElement = element;
+    if (!name) {
+      name = element.nodeName.toLowerCase();
+    }
+    this.currentName = name;
+    this.tip.updateText(name);
+    this.updatePosition(element);
+    this.resizeObserver.observe(element);
+  }
+  updatePosition(element) {
+    var _this_rect;
+    const outerBox = {
+      top: Number.POSITIVE_INFINITY,
+      right: Number.NEGATIVE_INFINITY,
+      bottom: Number.NEGATIVE_INFINITY,
+      left: Number.POSITIVE_INFINITY
+    };
+    const box = (0, _utils.getNestedBoundingClientRect)(element, this.window);
+    const dims = (0, _utils.getElementDimensions)(element);
+    outerBox.top = Math.min(outerBox.top, box.top - dims.marginTop);
+    outerBox.right = Math.max(outerBox.right, box.left + box.width + dims.marginRight);
+    outerBox.bottom = Math.max(outerBox.bottom, box.top + box.height + dims.marginBottom);
+    outerBox.left = Math.min(outerBox.left, box.left - dims.marginLeft);
+    (_this_rect = this.rect) === null || _this_rect === void 0 ? void 0 : _this_rect.update(box, dims);
+    const tipBounds = (0, _utils.getNestedBoundingClientRect)(this.tipBoundsWindow.document.documentElement, this.window);
+    if (box.width === 0 || box.height === 0) {
+      this.tip.invisible();
+    }
+    this.tip.updatePosition({
+      top: outerBox.top,
+      left: outerBox.left,
+      height: outerBox.bottom - outerBox.top,
+      width: outerBox.right - outerBox.left
+    }, {
+      top: tipBounds.top + this.tipBoundsWindow.scrollY,
+      left: tipBounds.left + this.tipBoundsWindow.scrollX,
+      height: this.tipBoundsWindow.innerHeight,
+      width: this.tipBoundsWindow.innerWidth
+    });
+  }
+  clearRect() {
+    var _this_rect;
+    (_this_rect = this.rect) === null || _this_rect === void 0 ? void 0 : _this_rect.remove();
+    this.tip.invisible();
+  }
+  constructor(positionUpdate) {
+    this.currentElement = null;
+    this.currentName = void 0;
+    this.positionUpdate = positionUpdate;
+    const currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+    this.window = currentWindow;
+    const tipBoundsWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+    this.tipBoundsWindow = tipBoundsWindow;
+    const doc = currentWindow.document;
+    this.container = doc.createElement("div");
+    this.container.style.zIndex = "9999999";
+    this.tip = new OverlayTip(doc, this.container);
+    this.rect = null;
+    let rafId = null;
+    this.resizeObserver = new ResizeObserver(() => {
+      var _this_positionUpdate, _this;
+      if (rafId) {
+        cancelAnimationFrame(rafId);
+      }
+      rafId = requestAnimationFrame(() => {
+        if (this.currentElement) {
+          this.updatePosition(this.currentElement);
+        }
+      });
+      (_this_positionUpdate = (_this = this).positionUpdate) === null || _this_positionUpdate === void 0 ? void 0 : _this_positionUpdate.call(_this);
+    });
+    doc.body.appendChild(this.container);
+  }
+}

package/dist/lib/Inspector/hooks/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+_export_star(require("./use-layout-effect"), exports);
+_export_star(require("./use-effect-event"), exports);
+_export_star(require("./use-mouse"), exports);
+function _export_star(from, to) {
+  Object.keys(from).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+      Object.defineProperty(to, k, {
+        enumerable: true,
+        get: function() {
+          return from[k];
+        }
+      });
+    }
+  });
+  return from;
+}

package/dist/lib/Inspector/hooks/use-effect-event.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useEffectEvent", {
+  enumerable: true,
+  get: function() {
+    return useEffectEvent;
+  }
+});
+const _react = require("react");
+const useEffectEvent = (callback) => {
+  const callbackRef = (0, _react.useRef)(callback);
+  callbackRef.current = (0, _react.useMemo)(() => callback, [
+    callback
+  ]);
+  const stableRef = (0, _react.useRef)();
+  if (!stableRef.current) {
+    stableRef.current = function(...args) {
+      var _callbackRef_current;
+      return (_callbackRef_current = callbackRef.current) === null || _callbackRef_current === void 0 ? void 0 : _callbackRef_current.apply(this, args);
+    };
+  }
+  return stableRef.current;
+};

package/dist/lib/Inspector/hooks/use-layout-effect.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useLayoutEffect", {
+  enumerable: true,
+  get: function() {
+    return useLayoutEffect;
+  }
+});
+const _react = require("react");
+var _window_document, _window;
+const useLayoutEffect = typeof window !== "undefined" && ((_window = window) === null || _window === void 0 ? void 0 : (_window_document = _window.document) === null || _window_document === void 0 ? void 0 : _window_document.createElement) ? _react.useLayoutEffect : _react.useEffect;

package/dist/lib/Inspector/hooks/use-mouse.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useMousePosition", {
+  enumerable: true,
+  get: function() {
+    return useMousePosition;
+  }
+});
+const _react = require("react");
+const useMousePosition = ({ disable }) => {
+  const mouseRef = (0, _react.useRef)({
+    x: 0,
+    y: 0
+  });
+  const recordMousePoint = (ev) => {
+    mouseRef.current.x = ev.clientX;
+    mouseRef.current.y = ev.clientY;
+  };
+  (0, _react.useEffect)(() => {
+    if (!disable) {
+      document.addEventListener("mousemove", recordMousePoint, true);
+    }
+    return () => {
+      document.removeEventListener("mousemove", recordMousePoint, true);
+    };
+  }, [
+    disable
+  ]);
+  return mouseRef;
+};

package/dist/lib/Inspector/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Inspector", {
+  enumerable: true,
+  get: function() {
+    return _Inspector.Inspector;
+  }
+});
+const _Inspector = require("./Inspector");

package/dist/lib/Inspector/utils/fiber.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  isNativeTagFiber: function() {
+    return isNativeTagFiber;
+  },
+  isReactSymbolFiber: function() {
+    return isReactSymbolFiber;
+  },
+  isForwardRef: function() {
+    return isForwardRef;
+  },
+  getElementFiber: function() {
+    return getElementFiber;
+  },
+  getElementFiberUpward: function() {
+    return getElementFiberUpward;
+  },
+  getDirectParentFiber: function() {
+    return getDirectParentFiber;
+  },
+  getFiberName: function() {
+    return getFiberName;
+  }
+});
+const isNativeTagFiber = (fiber) => typeof (fiber === null || fiber === void 0 ? void 0 : fiber.type) === "string";
+const isReactSymbolFiber = (fiber) => {
+  var _fiber_type;
+  return typeof (fiber === null || fiber === void 0 ? void 0 : (_fiber_type = fiber.type) === null || _fiber_type === void 0 ? void 0 : _fiber_type.$$typeof) === "symbol";
+};
+const isForwardRef = (fiber) => {
+  var _fiber_type;
+  return (fiber === null || fiber === void 0 ? void 0 : (_fiber_type = fiber.type) === null || _fiber_type === void 0 ? void 0 : _fiber_type.$$typeof) === Symbol.for("react.forward_ref");
+};
+const getElementFiber = (element) => {
+  const fiberKey = Object.keys(element).find((key) => (
+    /**
+    * for react <= v16.13.1
+    * https://github.com/facebook/react/blob/v16.13.1/packages/react-dom/src/client/ReactDOMComponentTree.js#L21
+    */
+    key.startsWith("__reactInternalInstance$") || /**
+    * for react >= v16.14.0
+    * https://github.com/facebook/react/blob/v16.14.0/packages/react-dom/src/client/ReactDOMComponentTree.js#L39
+    */
+    key.startsWith("__reactFiber$")
+  ));
+  if (fiberKey) {
+    return element[fiberKey];
+  }
+  return void 0;
+};
+const getElementFiberUpward = (element) => {
+  if (!element)
+    return void 0;
+  const fiber = getElementFiber(element);
+  if (fiber)
+    return fiber;
+  return getElementFiberUpward(element.parentElement);
+};
+const getDirectParentFiber = (child) => {
+  let current = child.return;
+  while (current) {
+    if (!isReactSymbolFiber(current)) {
+      return current;
+    }
+    current = current.return;
+  }
+  return null;
+};
+const getFiberName = (fiber) => {
+  var _fiber_pendingProps;
+  const fiberType = fiber === null || fiber === void 0 ? void 0 : fiber.type;
+  if (!fiberType)
+    return void 0;
+  const { displayName, name } = fiberType;
+  if (fiber === null || fiber === void 0 ? void 0 : (_fiber_pendingProps = fiber.pendingProps) === null || _fiber_pendingProps === void 0 ? void 0 : _fiber_pendingProps["data-miaoda-component-name"]) {
+    return fiber.pendingProps["data-miaoda-component-name"];
+  }
+  if (typeof displayName === "string") {
+    return displayName;
+  }
+  if (typeof name === "string") {
+    return name;
+  }
+  return void 0;
+};

package/dist/lib/Inspector/utils/highlight.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "setupHighlighter", {
+  enumerable: true,
+  get: function() {
+    return setupHighlighter;
+  }
+});
+let iframesListeningTo = /* @__PURE__ */ new Set();
+function setupHighlighter(handlers) {
+  function onClick(event) {
+    var _handlers_onClick;
+    event.preventDefault();
+    event.stopPropagation();
+    (_handlers_onClick = handlers.onClick) === null || _handlers_onClick === void 0 ? void 0 : _handlers_onClick.call(handlers, event.target);
+  }
+  function onMouseEvent(event) {
+    event.stopPropagation();
+  }
+  function onPointerDown(event) {
+    event.stopPropagation();
+  }
+  function onPointerOver(event) {
+    var _handlers_onPointerOver;
+    event.preventDefault();
+    event.stopPropagation();
+    const target = event.target;
+    if (target.tagName === "IFRAME") {
+      const iframe = target;
+      try {
+        if (!iframesListeningTo.has(iframe)) {
+          const window1 = iframe.contentWindow;
+          registerListenersOnWindow(window1);
+          iframesListeningTo.add(iframe);
+        }
+      } catch (error) {
+      }
+    }
+    (_handlers_onPointerOver = handlers.onPointerOver) === null || _handlers_onPointerOver === void 0 ? void 0 : _handlers_onPointerOver.call(handlers, event.target);
+  }
+  function onPointerUp(event) {
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  function removeListenersOnWindow(window1) {
+    if (window1 && typeof window1.removeEventListener === "function") {
+      window1.removeEventListener("click", onClick, true);
+      window1.removeEventListener("mousedown", onMouseEvent, true);
+      window1.removeEventListener("mouseover", onMouseEvent, true);
+      window1.removeEventListener("mouseup", onMouseEvent, true);
+      window1.removeEventListener("pointerdown", onPointerDown, true);
+      window1.removeEventListener("pointerover", onPointerOver, true);
+      window1.removeEventListener("pointerup", onPointerUp, true);
+    }
+  }
+  function stopInspectingNative() {
+    removeListenersOnWindow(window);
+    iframesListeningTo.forEach((frame) => {
+      try {
+        removeListenersOnWindow(frame.contentWindow);
+      } catch (error) {
+      }
+    });
+    iframesListeningTo = /* @__PURE__ */ new Set();
+  }
+  function registerListenersOnWindow(window1) {
+    if (window1 && typeof window1.addEventListener === "function") {
+      window1.addEventListener("click", onClick, true);
+      window1.addEventListener("mousedown", onMouseEvent, true);
+      window1.addEventListener("mouseover", onMouseEvent, true);
+      window1.addEventListener("mouseup", onMouseEvent, true);
+      window1.addEventListener("pointerdown", onPointerDown, true);
+      window1.addEventListener("pointerover", onPointerOver, true);
+      window1.addEventListener("pointerup", onPointerUp, true);
+    }
+  }
+  function startInspectingNative() {
+    registerListenersOnWindow(window);
+  }
+  startInspectingNative();
+  return stopInspectingNative;
+}