@likec4/diagram 1.27.3 → 1.28.1

package/dist/node_modules/.pnpm/react@19.0.0/node_modules/react/cjs/react.production.js

@@ -0,0 +1,548 @@
+import { __exports as react_production } from '../../../../../../_virtual/react.production.js';
+
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReact_production;
+
+function requireReact_production () {
+	if (hasRequiredReact_production) return react_production;
+	hasRequiredReact_production = 1;
+	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+	  REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+	  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+	  REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+	  REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+	  REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+	  REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+	  REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+	  REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+	  REACT_MEMO_TYPE = Symbol.for("react.memo"),
+	  REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+	  MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+	function getIteratorFn(maybeIterable) {
+	  if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+	  maybeIterable =
+	    (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
+	    maybeIterable["@@iterator"];
+	  return "function" === typeof maybeIterable ? maybeIterable : null;
+	}
+	var ReactNoopUpdateQueue = {
+	    isMounted: function () {
+	      return false;
+	    },
+	    enqueueForceUpdate: function () {},
+	    enqueueReplaceState: function () {},
+	    enqueueSetState: function () {}
+	  },
+	  assign = Object.assign,
+	  emptyObject = {};
+	function Component(props, context, updater) {
+	  this.props = props;
+	  this.context = context;
+	  this.refs = emptyObject;
+	  this.updater = updater || ReactNoopUpdateQueue;
+	}
+	Component.prototype.isReactComponent = {};
+	Component.prototype.setState = function (partialState, callback) {
+	  if (
+	    "object" !== typeof partialState &&
+	    "function" !== typeof partialState &&
+	    null != partialState
+	  )
+	    throw Error(
+	      "takes an object of state variables to update or a function which returns an object of state variables."
+	    );
+	  this.updater.enqueueSetState(this, partialState, callback, "setState");
+	};
+	Component.prototype.forceUpdate = function (callback) {
+	  this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+	};
+	function ComponentDummy() {}
+	ComponentDummy.prototype = Component.prototype;
+	function PureComponent(props, context, updater) {
+	  this.props = props;
+	  this.context = context;
+	  this.refs = emptyObject;
+	  this.updater = updater || ReactNoopUpdateQueue;
+	}
+	var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());
+	pureComponentPrototype.constructor = PureComponent;
+	assign(pureComponentPrototype, Component.prototype);
+	pureComponentPrototype.isPureReactComponent = true;
+	var isArrayImpl = Array.isArray,
+	  ReactSharedInternals = { H: null, A: null, T: null, S: null },
+	  hasOwnProperty = Object.prototype.hasOwnProperty;
+	function ReactElement(type, key, self, source, owner, props) {
+	  self = props.ref;
+	  return {
+	    $$typeof: REACT_ELEMENT_TYPE,
+	    type: type,
+	    key: key,
+	    ref: void 0 !== self ? self : null,
+	    props: props
+	  };
+	}
+	function cloneAndReplaceKey(oldElement, newKey) {
+	  return ReactElement(
+	    oldElement.type,
+	    newKey,
+	    void 0,
+	    void 0,
+	    void 0,
+	    oldElement.props
+	  );
+	}
+	function isValidElement(object) {
+	  return (
+	    "object" === typeof object &&
+	    null !== object &&
+	    object.$$typeof === REACT_ELEMENT_TYPE
+	  );
+	}
+	function escape(key) {
+	  var escaperLookup = { "=": "=0", ":": "=2" };
+	  return (
+	    "$" +
+	    key.replace(/[=:]/g, function (match) {
+	      return escaperLookup[match];
+	    })
+	  );
+	}
+	var userProvidedKeyEscapeRegex = /\/+/g;
+	function getElementKey(element, index) {
+	  return "object" === typeof element && null !== element && null != element.key
+	    ? escape("" + element.key)
+	    : index.toString(36);
+	}
+	function noop$1() {}
+	function resolveThenable(thenable) {
+	  switch (thenable.status) {
+	    case "fulfilled":
+	      return thenable.value;
+	    case "rejected":
+	      throw thenable.reason;
+	    default:
+	      switch (
+	        ("string" === typeof thenable.status
+	          ? thenable.then(noop$1, noop$1)
+	          : ((thenable.status = "pending"),
+	            thenable.then(
+	              function (fulfilledValue) {
+	                "pending" === thenable.status &&
+	                  ((thenable.status = "fulfilled"),
+	                  (thenable.value = fulfilledValue));
+	              },
+	              function (error) {
+	                "pending" === thenable.status &&
+	                  ((thenable.status = "rejected"), (thenable.reason = error));
+	              }
+	            )),
+	        thenable.status)
+	      ) {
+	        case "fulfilled":
+	          return thenable.value;
+	        case "rejected":
+	          throw thenable.reason;
+	      }
+	  }
+	  throw thenable;
+	}
+	function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+	  var type = typeof children;
+	  if ("undefined" === type || "boolean" === type) children = null;
+	  var invokeCallback = false;
+	  if (null === children) invokeCallback = true;
+	  else
+	    switch (type) {
+	      case "bigint":
+	      case "string":
+	      case "number":
+	        invokeCallback = true;
+	        break;
+	      case "object":
+	        switch (children.$$typeof) {
+	          case REACT_ELEMENT_TYPE:
+	          case REACT_PORTAL_TYPE:
+	            invokeCallback = true;
+	            break;
+	          case REACT_LAZY_TYPE:
+	            return (
+	              (invokeCallback = children._init),
+	              mapIntoArray(
+	                invokeCallback(children._payload),
+	                array,
+	                escapedPrefix,
+	                nameSoFar,
+	                callback
+	              )
+	            );
+	        }
+	    }
+	  if (invokeCallback)
+	    return (
+	      (callback = callback(children)),
+	      (invokeCallback =
+	        "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar),
+	      isArrayImpl(callback)
+	        ? ((escapedPrefix = ""),
+	          null != invokeCallback &&
+	            (escapedPrefix =
+	              invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"),
+	          mapIntoArray(callback, array, escapedPrefix, "", function (c) {
+	            return c;
+	          }))
+	        : null != callback &&
+	          (isValidElement(callback) &&
+	            (callback = cloneAndReplaceKey(
+	              callback,
+	              escapedPrefix +
+	                (null == callback.key ||
+	                (children && children.key === callback.key)
+	                  ? ""
+	                  : ("" + callback.key).replace(
+	                      userProvidedKeyEscapeRegex,
+	                      "$&/"
+	                    ) + "/") +
+	                invokeCallback
+	            )),
+	          array.push(callback)),
+	      1
+	    );
+	  invokeCallback = 0;
+	  var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
+	  if (isArrayImpl(children))
+	    for (var i = 0; i < children.length; i++)
+	      (nameSoFar = children[i]),
+	        (type = nextNamePrefix + getElementKey(nameSoFar, i)),
+	        (invokeCallback += mapIntoArray(
+	          nameSoFar,
+	          array,
+	          escapedPrefix,
+	          type,
+	          callback
+	        ));
+	  else if (((i = getIteratorFn(children)), "function" === typeof i))
+	    for (
+	      children = i.call(children), i = 0;
+	      !(nameSoFar = children.next()).done;
+
+	    )
+	      (nameSoFar = nameSoFar.value),
+	        (type = nextNamePrefix + getElementKey(nameSoFar, i++)),
+	        (invokeCallback += mapIntoArray(
+	          nameSoFar,
+	          array,
+	          escapedPrefix,
+	          type,
+	          callback
+	        ));
+	  else if ("object" === type) {
+	    if ("function" === typeof children.then)
+	      return mapIntoArray(
+	        resolveThenable(children),
+	        array,
+	        escapedPrefix,
+	        nameSoFar,
+	        callback
+	      );
+	    array = String(children);
+	    throw Error(
+	      "Objects are not valid as a React child (found: " +
+	        ("[object Object]" === array
+	          ? "object with keys {" + Object.keys(children).join(", ") + "}"
+	          : array) +
+	        "). If you meant to render a collection of children, use an array instead."
+	    );
+	  }
+	  return invokeCallback;
+	}
+	function mapChildren(children, func, context) {
+	  if (null == children) return children;
+	  var result = [],
+	    count = 0;
+	  mapIntoArray(children, result, "", "", function (child) {
+	    return func.call(context, child, count++);
+	  });
+	  return result;
+	}
+	function lazyInitializer(payload) {
+	  if (-1 === payload._status) {
+	    var ctor = payload._result;
+	    ctor = ctor();
+	    ctor.then(
+	      function (moduleObject) {
+	        if (0 === payload._status || -1 === payload._status)
+	          (payload._status = 1), (payload._result = moduleObject);
+	      },
+	      function (error) {
+	        if (0 === payload._status || -1 === payload._status)
+	          (payload._status = 2), (payload._result = error);
+	      }
+	    );
+	    -1 === payload._status && ((payload._status = 0), (payload._result = ctor));
+	  }
+	  if (1 === payload._status) return payload._result.default;
+	  throw payload._result;
+	}
+	var reportGlobalError =
+	  "function" === typeof reportError
+	    ? reportError
+	    : function (error) {
+	        if (
+	          "object" === typeof window &&
+	          "function" === typeof window.ErrorEvent
+	        ) {
+	          var event = new window.ErrorEvent("error", {
+	            bubbles: true,
+	            cancelable: true,
+	            message:
+	              "object" === typeof error &&
+	              null !== error &&
+	              "string" === typeof error.message
+	                ? String(error.message)
+	                : String(error),
+	            error: error
+	          });
+	          if (!window.dispatchEvent(event)) return;
+	        } else if (
+	          "object" === typeof process &&
+	          "function" === typeof process.emit
+	        ) {
+	          process.emit("uncaughtException", error);
+	          return;
+	        }
+	        console.error(error);
+	      };
+	function noop() {}
+	react_production.Children = {
+	  map: mapChildren,
+	  forEach: function (children, forEachFunc, forEachContext) {
+	    mapChildren(
+	      children,
+	      function () {
+	        forEachFunc.apply(this, arguments);
+	      },
+	      forEachContext
+	    );
+	  },
+	  count: function (children) {
+	    var n = 0;
+	    mapChildren(children, function () {
+	      n++;
+	    });
+	    return n;
+	  },
+	  toArray: function (children) {
+	    return (
+	      mapChildren(children, function (child) {
+	        return child;
+	      }) || []
+	    );
+	  },
+	  only: function (children) {
+	    if (!isValidElement(children))
+	      throw Error(
+	        "React.Children.only expected to receive a single React element child."
+	      );
+	    return children;
+	  }
+	};
+	react_production.Component = Component;
+	react_production.Fragment = REACT_FRAGMENT_TYPE;
+	react_production.Profiler = REACT_PROFILER_TYPE;
+	react_production.PureComponent = PureComponent;
+	react_production.StrictMode = REACT_STRICT_MODE_TYPE;
+	react_production.Suspense = REACT_SUSPENSE_TYPE;
+	react_production.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
+	  ReactSharedInternals;
+	react_production.act = function () {
+	  throw Error("act(...) is not supported in production builds of React.");
+	};
+	react_production.cache = function (fn) {
+	  return function () {
+	    return fn.apply(null, arguments);
+	  };
+	};
+	react_production.cloneElement = function (element, config, children) {
+	  if (null === element || void 0 === element)
+	    throw Error(
+	      "The argument must be a React element, but you passed " + element + "."
+	    );
+	  var props = assign({}, element.props),
+	    key = element.key,
+	    owner = void 0;
+	  if (null != config)
+	    for (propName in (void 0 !== config.ref && (owner = void 0),
+	    void 0 !== config.key && (key = "" + config.key),
+	    config))
+	      !hasOwnProperty.call(config, propName) ||
+	        "key" === propName ||
+	        "__self" === propName ||
+	        "__source" === propName ||
+	        ("ref" === propName && void 0 === config.ref) ||
+	        (props[propName] = config[propName]);
+	  var propName = arguments.length - 2;
+	  if (1 === propName) props.children = children;
+	  else if (1 < propName) {
+	    for (var childArray = Array(propName), i = 0; i < propName; i++)
+	      childArray[i] = arguments[i + 2];
+	    props.children = childArray;
+	  }
+	  return ReactElement(element.type, key, void 0, void 0, owner, props);
+	};
+	react_production.createContext = function (defaultValue) {
+	  defaultValue = {
+	    $$typeof: REACT_CONTEXT_TYPE,
+	    _currentValue: defaultValue,
+	    _currentValue2: defaultValue,
+	    _threadCount: 0,
+	    Provider: null,
+	    Consumer: null
+	  };
+	  defaultValue.Provider = defaultValue;
+	  defaultValue.Consumer = {
+	    $$typeof: REACT_CONSUMER_TYPE,
+	    _context: defaultValue
+	  };
+	  return defaultValue;
+	};
+	react_production.createElement = function (type, config, children) {
+	  var propName,
+	    props = {},
+	    key = null;
+	  if (null != config)
+	    for (propName in (void 0 !== config.key && (key = "" + config.key), config))
+	      hasOwnProperty.call(config, propName) &&
+	        "key" !== propName &&
+	        "__self" !== propName &&
+	        "__source" !== propName &&
+	        (props[propName] = config[propName]);
+	  var childrenLength = arguments.length - 2;
+	  if (1 === childrenLength) props.children = children;
+	  else if (1 < childrenLength) {
+	    for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
+	      childArray[i] = arguments[i + 2];
+	    props.children = childArray;
+	  }
+	  if (type && type.defaultProps)
+	    for (propName in ((childrenLength = type.defaultProps), childrenLength))
+	      void 0 === props[propName] &&
+	        (props[propName] = childrenLength[propName]);
+	  return ReactElement(type, key, void 0, void 0, null, props);
+	};
+	react_production.createRef = function () {
+	  return { current: null };
+	};
+	react_production.forwardRef = function (render) {
+	  return { $$typeof: REACT_FORWARD_REF_TYPE, render: render };
+	};
+	react_production.isValidElement = isValidElement;
+	react_production.lazy = function (ctor) {
+	  return {
+	    $$typeof: REACT_LAZY_TYPE,
+	    _payload: { _status: -1, _result: ctor },
+	    _init: lazyInitializer
+	  };
+	};
+	react_production.memo = function (type, compare) {
+	  return {
+	    $$typeof: REACT_MEMO_TYPE,
+	    type: type,
+	    compare: void 0 === compare ? null : compare
+	  };
+	};
+	react_production.startTransition = function (scope) {
+	  var prevTransition = ReactSharedInternals.T,
+	    currentTransition = {};
+	  ReactSharedInternals.T = currentTransition;
+	  try {
+	    var returnValue = scope(),
+	      onStartTransitionFinish = ReactSharedInternals.S;
+	    null !== onStartTransitionFinish &&
+	      onStartTransitionFinish(currentTransition, returnValue);
+	    "object" === typeof returnValue &&
+	      null !== returnValue &&
+	      "function" === typeof returnValue.then &&
+	      returnValue.then(noop, reportGlobalError);
+	  } catch (error) {
+	    reportGlobalError(error);
+	  } finally {
+	    ReactSharedInternals.T = prevTransition;
+	  }
+	};
+	react_production.unstable_useCacheRefresh = function () {
+	  return ReactSharedInternals.H.useCacheRefresh();
+	};
+	react_production.use = function (usable) {
+	  return ReactSharedInternals.H.use(usable);
+	};
+	react_production.useActionState = function (action, initialState, permalink) {
+	  return ReactSharedInternals.H.useActionState(action, initialState, permalink);
+	};
+	react_production.useCallback = function (callback, deps) {
+	  return ReactSharedInternals.H.useCallback(callback, deps);
+	};
+	react_production.useContext = function (Context) {
+	  return ReactSharedInternals.H.useContext(Context);
+	};
+	react_production.useDebugValue = function () {};
+	react_production.useDeferredValue = function (value, initialValue) {
+	  return ReactSharedInternals.H.useDeferredValue(value, initialValue);
+	};
+	react_production.useEffect = function (create, deps) {
+	  return ReactSharedInternals.H.useEffect(create, deps);
+	};
+	react_production.useId = function () {
+	  return ReactSharedInternals.H.useId();
+	};
+	react_production.useImperativeHandle = function (ref, create, deps) {
+	  return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
+	};
+	react_production.useInsertionEffect = function (create, deps) {
+	  return ReactSharedInternals.H.useInsertionEffect(create, deps);
+	};
+	react_production.useLayoutEffect = function (create, deps) {
+	  return ReactSharedInternals.H.useLayoutEffect(create, deps);
+	};
+	react_production.useMemo = function (create, deps) {
+	  return ReactSharedInternals.H.useMemo(create, deps);
+	};
+	react_production.useOptimistic = function (passthrough, reducer) {
+	  return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
+	};
+	react_production.useReducer = function (reducer, initialArg, init) {
+	  return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
+	};
+	react_production.useRef = function (initialValue) {
+	  return ReactSharedInternals.H.useRef(initialValue);
+	};
+	react_production.useState = function (initialState) {
+	  return ReactSharedInternals.H.useState(initialState);
+	};
+	react_production.useSyncExternalStore = function (
+	  subscribe,
+	  getSnapshot,
+	  getServerSnapshot
+	) {
+	  return ReactSharedInternals.H.useSyncExternalStore(
+	    subscribe,
+	    getSnapshot,
+	    getServerSnapshot
+	  );
+	};
+	react_production.useTransition = function () {
+	  return ReactSharedInternals.H.useTransition();
+	};
+	react_production.version = "19.0.0";
+	return react_production;
+}
+
+export { requireReact_production as __require };

package/dist/node_modules/.pnpm/react@19.0.0/node_modules/react/index.js

@@ -0,0 +1,15 @@
+import { __module as react } from '../../../../../_virtual/index2.js';
+import { __require as requireReact_production } from './cjs/react.production.js';
+
+var hasRequiredReact;
+
+function requireReact () {
+	if (hasRequiredReact) return react.exports;
+	hasRequiredReact = 1;
+	{
+	  react.exports = requireReact_production();
+	}
+	return react.exports;
+}
+
+export { requireReact as __require };

package/dist/overlays/Overlays.js

@@ -3,9 +3,9 @@ import { nonexhaustive } from '@likec4/core';
 import { Box, Notification, ScrollAreaAutosize, Code, Group, Button } from '@mantine/core';
 import { IconX } from '@tabler/icons-react';
 import { useSelector } from '@xstate/react';
-import { useReducedMotionConfig, LayoutGroup, AnimatePresence } from 'framer-motion';
-import { animate } from 'framer-motion/dom';
-import { memo, useMemo, useEffect } from 'react';
+import { animate } from 'motion';
+import { useReducedMotionConfig, LayoutGroup, AnimatePresence } from 'motion/react';
+import { r as reactExports } from '../_virtual/index.js';
 import { ErrorBoundary } from 'react-error-boundary';
 import { isNonNullish } from 'remeda';
 import { ElementDetails } from './element-details/ElementDetails.js';
@@ -65,15 +65,15 @@ const compareSelectOverlays = (a, b) => {
     return overlay.actorRef === b[i].actorRef;
   });
 };
-const Overlays = memo(({ overlaysActorRef }) => {
+const Overlays = reactExports.memo(({ overlaysActorRef }) => {
   const xyflowDomNode = useXYStore((s) => s.domNode);
-  const xyflowRendererDom = useMemo(() => xyflowDomNode?.querySelector(".react-flow__renderer") ?? null, [
+  const xyflowRendererDom = reactExports.useMemo(() => xyflowDomNode?.querySelector(".react-flow__renderer") ?? null, [
     xyflowDomNode
   ]);
   const overlays = useSelector(overlaysActorRef, selectOverlays, compareSelectOverlays);
   const isMotionReduced = useReducedMotionConfig() ?? false;
   const isActiveOverlay = overlays.length > 0;
-  useEffect(() => {
+  reactExports.useEffect(() => {
     if (!xyflowRendererDom || isMotionReduced) return;
     animate(xyflowRendererDom, {
       opacity: isActiveOverlay ? 0.7 : 1,
@@ -92,7 +92,7 @@ const Overlays = memo(({ overlaysActorRef }) => {
         return /* @__PURE__ */ jsx(
           Overlay,
           {
-            overlayLevel: Math.min(index, 3),
+            overlayLevel: index,
             onClose: () => close(overlay.actorRef),
             children: /* @__PURE__ */ jsx(RelationshipsBrowser, { actorRef: overlay.actorRef })
           },
@@ -102,7 +102,7 @@ const Overlays = memo(({ overlaysActorRef }) => {
         return /* @__PURE__ */ jsx(
           Overlay,
           {
-            overlayLevel: Math.min(index, 3),
+            overlayLevel: index,
             onClose: () => close(overlay.actorRef),
             children: /* @__PURE__ */ jsx(RelationshipDetails, { actorRef: overlay.actorRef })
           },

package/dist/overlays/element-details/ElementDetailsCard.js

@@ -5,8 +5,8 @@ import { RemoveScroll, Card, Box, Group, Text, CloseButton, Badge, Flex, ActionI
 import { useViewportSize, useSessionStorage } from '@mantine/hooks';
 import { useSyncedRef, useDebouncedCallback, useTimeoutEffect } from '@react-hookz/web';
 import { IconExternalLink, IconFileSymlink, IconZoomScan, IconStack2 } from '@tabler/icons-react';
-import { useDragControls, useMotionValue, m } from 'framer-motion';
-import { useState, useCallback, useRef } from 'react';
+import { useDragControls, useMotionValue, m } from 'motion/react';
+import { r as reactExports } from '../../_virtual/index.js';
 import { pipe, map, partition, only, clamp, isNullish } from 'remeda';
 import { Link } from '../../components/Link.js';
 import { useDiagram } from '../../hooks/useDiagram.js';
@@ -56,7 +56,7 @@ function ElementDetailsCard({
   fqn,
   onClose
 }) {
-  const [opened, setOpened] = useState(false);
+  const [opened, setOpened] = reactExports.useState(false);
   const windowSize = useViewportSize();
   const windowWidth = windowSize.width || window.innerWidth || 1200, windowHeight = windowSize.height || window.innerHeight || 800;
   const [activeTab, setActiveTab] = useSessionStorage({
@@ -119,11 +119,11 @@ function ElementDetailsCard({
     width.set(_width);
     height.set(_height);
   }, [_width, _height]);
-  const handleDrag = useCallback((_, info) => {
+  const handleDrag = reactExports.useCallback((_, info) => {
     width.set(Math.max(width.get() + info.delta.x, 320));
     height.set(Math.max(height.get() + info.delta.y, 300));
   }, []);
-  const ref = useRef(null);
+  const ref = reactExports.useRef(null);
   const onCloseRef = useSyncedRef(onClose);
   const close = useDebouncedCallback(
     () => {

package/dist/overlays/element-details/TabPanelDeployments.js

@@ -1,7 +1,7 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { useTree, Alert, Tree, Box, rem, Button, Group, Text, ThemeIcon, Menu } from '@mantine/core';
 import { IconInfoCircle, IconTarget, IconZoomScan } from '@tabler/icons-react';
-import { memo, useMemo, useEffect } from 'react';
+import { r as reactExports } from '../../_virtual/index.js';
 import { useDiagram } from '../../hooks/useDiagram.js';
 import { useLikeC4Model } from '../../likec4model/useLikeC4Model.js';
 import { treeNodeLabel, treeNode, nodeLabel, instanceLabel } from './TabPanelDeployments.css.js';
@@ -70,13 +70,16 @@ const DeployedInstanceRenderer = ({
     ] })
   ] });
 };
-const TabPanelDeployments = memo(({ elementFqn }) => {
+const setHoveredNode = () => {
+};
+const TabPanelDeployments = reactExports.memo(({ elementFqn }) => {
   const element = useLikeC4Model(true).element(elementFqn);
   const deployments = [...element.deployments()];
   const tree = useTree({
     multiple: false
   });
-  const data = useMemo(() => {
+  tree.setHoveredNode = setHoveredNode;
+  const data = reactExports.useMemo(() => {
     let roots = [];
     let treeItems = /* @__PURE__ */ new Map();
     for (const instance of element.deployments()) {
@@ -110,7 +113,7 @@ const TabPanelDeployments = memo(({ elementFqn }) => {
     }
     return roots;
   }, [element]);
-  useEffect(() => {
+  reactExports.useEffect(() => {
     tree.expandAllNodes();
   }, [data]);
   if (deployments.length === 0) {