@zythum02/fello-server 0.1.55 → 0.1.57

package/out/renderer/assets/PopoverPopup-BcHY-oda.js

@@ -0,0 +1,591 @@
+import { c as createLucideIcon, r as reactExports, ay as formatErrorMessage, az as ReactStore, aA as popupStoreSelectors, aB as triggerHover, aC as triggerPress, aD as escapeKey, aE as attachPreventUnmountOnClose, aF as closePress, aG as PATIENT_CLICK_THRESHOLD, ar as reactDomExports, aH as focusOut, aI as createPopupOpenState, aJ as createInitialPopupStoreState, aK as Timeout, aL as PopupTriggerMap, j as jsxRuntimeExports, aM as FloatingTree, aN as fastComponent, aO as usePopupRootSync, aP as useImplicitActiveTrigger, aQ as useOpenStateTransitions, aR as createChangeEventDetails, aS as imperativeAction, aT as PopupHandleAttachment, aU as usePopupRootStore, aV as useDismiss, aW as usePopupInteractionProps, aX as fastComponentRef, aY as usePopupHandleStore, aZ as useBaseUiId, a_ as useTriggerDataForwarding, a$ as useHoverReferenceInteraction, b0 as safePolygon, b1 as useClick, b2 as useOpenMethodTriggerProps, b3 as useButton, b4 as useTriggerFocusGuards, b5 as useRenderElement, b6 as CLICK_TRIGGER_IDENTIFIER, b7 as FocusGuard, b8 as pressableTriggerOpenStateMapping, b9 as triggerOpenStateMapping, ba as FloatingPortal, bb as POPUP_COLLISION_AVOIDANCE, bc as useFloatingNodeId, bd as useAnimationsFinished, be as useAnchorPositioning, bf as useIsoLayoutEffect, bg as useAnchoredPopupScrollLock, bh as usePositioner, bi as InternalBackdrop, bj as inertValue, bk as FloatingNode, bl as useStableCallback, bm as useToolbarRootContext, bn as useOpenChangeComplete, bo as useHoverFloatingInteraction, bp as createDefaultInitialFocus, bq as FOCUSABLE_POPUP_PROPS, br as COMPOSITE_KEYS, bs as getDisabledMountTransitionStyles, bt as FloatingFocusManager, bu as isHTMLElement, bv as popupTransitionStateMapping } from "./index-CKDwIiIb.js";
+const __iconData = {
+  name: "settings-2",
+  size: 24,
+  node: [
+    ["path", { d: "M14 17H5", key: "gfn3mx" }],
+    ["path", { d: "M19 7h-9", key: "6i9tg" }],
+    ["circle", { cx: "17", cy: "17", r: "3", key: "18b49y" }],
+    ["circle", { cx: "7", cy: "7", r: "3", key: "dfmy0x" }]
+  ]
+};
+__iconData.node;
+const Settings2 = createLucideIcon(__iconData);
+const PopoverRootContext = /* @__PURE__ */ reactExports.createContext(void 0);
+function usePopoverRootContext(optional) {
+  const context = reactExports.useContext(PopoverRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(formatErrorMessage(47));
+  }
+  return context;
+}
+const selectors = {
+  ...popupStoreSelectors,
+  disabled: (state) => state.disabled,
+  instantType: (state) => state.instantType,
+  openMethod: (state) => state.openMethod,
+  openChangeReason: (state) => state.openChangeReason,
+  modal: (state) => state.modal,
+  focusManagerModal: (state) => state.focusManagerModal,
+  stickIfOpen: (state) => state.stickIfOpen,
+  titleElementId: (state) => state.titleElementId,
+  descriptionElementId: (state) => state.descriptionElementId,
+  openOnHover: (state) => state.openOnHover,
+  closeDelay: (state) => state.closeDelay,
+  adaptiveOrigin: (state) => state.adaptiveOrigin
+};
+class PopoverStore extends ReactStore {
+  constructor(initialState, floatingId, nested) {
+    const triggerElements = new PopupTriggerMap();
+    super(createInitialState(initialState, triggerElements, floatingId, nested), createInitialContext(triggerElements), selectors);
+  }
+  setOpen = (nextOpen, eventDetails) => {
+    const isHover = eventDetails.reason === triggerHover;
+    const isKeyboardClick = eventDetails.reason === triggerPress && eventDetails.event.detail === 0;
+    const isDismissClose = !nextOpen && (eventDetails.reason === escapeKey || eventDetails.reason == null);
+    const shouldPreventUnmountOnClose = attachPreventUnmountOnClose(eventDetails);
+    const activeTriggerId = this.select("activeTriggerId");
+    if (!nextOpen && eventDetails.reason === closePress && eventDetails.trigger == null && activeTriggerId != null) {
+      eventDetails.trigger = this.context.triggerElements.getById(activeTriggerId) ?? this.select("activeTriggerElement") ?? void 0;
+    }
+    this.context.onOpenChange?.(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    this.state.floatingRootContext.dispatchOpenChange(nextOpen, eventDetails);
+    const changeState = () => {
+      const popupOpenState = createPopupOpenState(this.state, nextOpen, eventDetails.trigger, shouldPreventUnmountOnClose());
+      popupOpenState.openChangeReason = eventDetails.reason;
+      this.update(popupOpenState);
+    };
+    if (isHover) {
+      this.set("stickIfOpen", true);
+      this.context.stickIfOpenTimeout.start(PATIENT_CLICK_THRESHOLD, () => {
+        this.set("stickIfOpen", false);
+      });
+      reactDomExports.flushSync(changeState);
+    } else {
+      changeState();
+    }
+    let instantType;
+    if (isKeyboardClick) {
+      instantType = "click";
+    } else if (isDismissClose) {
+      instantType = "dismiss";
+    } else if (eventDetails.reason === focusOut) {
+      instantType = "focus";
+    }
+    this.set("instantType", instantType);
+  };
+}
+function createInitialState(initialState, triggerElements, floatingId, nested = false) {
+  const state = {
+    ...createInitialPopupStoreState(triggerElements, floatingId, nested),
+    disabled: false,
+    modal: false,
+    focusManagerModal: false,
+    instantType: void 0,
+    openMethod: null,
+    openChangeReason: null,
+    titleElementId: void 0,
+    descriptionElementId: void 0,
+    stickIfOpen: true,
+    openOnHover: false,
+    closeDelay: 0,
+    adaptiveOrigin: void 0,
+    ...initialState
+  };
+  if (state.open && initialState?.mounted === void 0) {
+    state.mounted = true;
+  }
+  return state;
+}
+function createInitialContext(triggerElements) {
+  return {
+    popupRef: /* @__PURE__ */ reactExports.createRef(),
+    onOpenChange: void 0,
+    onOpenChangeComplete: void 0,
+    triggerFocusTargetRef: /* @__PURE__ */ reactExports.createRef(),
+    beforeContentFocusGuardRef: /* @__PURE__ */ reactExports.createRef(),
+    stickIfOpenTimeout: new Timeout(),
+    triggerElements
+  };
+}
+const PopoverRootComponent = fastComponent(function PopoverRootComponent2({
+  props
+}) {
+  const {
+    children,
+    open: openProp,
+    defaultOpen = false,
+    onOpenChange,
+    onOpenChangeComplete,
+    modal = false,
+    handle,
+    triggerId: triggerIdProp,
+    defaultTriggerId: defaultTriggerIdProp = null
+  } = props;
+  const store = usePopoverRootStore(handle, {
+    modal,
+    open: defaultOpen,
+    openProp,
+    activeTriggerId: defaultTriggerIdProp,
+    triggerIdProp
+  });
+  store.useControlledProp("openProp", openProp);
+  store.useControlledProp("triggerIdProp", triggerIdProp);
+  const open = store.useState("open");
+  const mounted = store.useState("mounted");
+  const payload = store.useState("payload");
+  store.useContextCallback("onOpenChange", onOpenChange);
+  store.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
+  usePopupRootSync(store, open);
+  useImplicitActiveTrigger(store);
+  const {
+    forceUnmount
+  } = useOpenStateTransitions(open, store, () => {
+    store.update({
+      stickIfOpen: true,
+      openChangeReason: null
+    });
+  });
+  store.useSyncedValues({
+    modal
+  });
+  reactExports.useEffect(() => {
+    if (!open) {
+      store.context.stickIfOpenTimeout.clear();
+    }
+  }, [store, open]);
+  reactExports.useImperativeHandle(props.actionsRef, () => ({
+    unmount: forceUnmount,
+    close: () => store.setOpen(false, createChangeEventDetails(imperativeAction))
+  }), [forceUnmount, store]);
+  const shouldRenderInteractions = open || mounted;
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(PopoverRootContext.Provider, {
+    value: store,
+    children: [handle && /* @__PURE__ */ jsxRuntimeExports.jsx(PopupHandleAttachment, {
+      handle,
+      store
+    }), shouldRenderInteractions && /* @__PURE__ */ jsxRuntimeExports.jsx(PopoverInteractions, {
+      store,
+      modal
+    }), typeof children === "function" ? children({
+      payload
+    }) : children]
+  });
+});
+function PopoverRoot(props) {
+  if (usePopoverRootContext(true)) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(PopoverRootComponent, {
+      props
+    });
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(FloatingTree, {
+    children: /* @__PURE__ */ jsxRuntimeExports.jsx(PopoverRootComponent, {
+      props
+    })
+  });
+}
+function usePopoverRootStore(handle, initialState) {
+  const store = usePopupRootStore((floatingId, nested) => new PopoverStore(initialState, floatingId, nested));
+  reactExports.useEffect(() => store.context.stickIfOpenTimeout.disposeEffect(), [store]);
+  return store;
+}
+function PopoverInteractions({
+  store,
+  modal
+}) {
+  const floatingRootContext = store.useState("floatingRootContext");
+  const dismiss = useDismiss(floatingRootContext, {
+    outsidePressEvent: {
+      // Ensure `aria-hidden` on outside elements is removed immediately
+      // on outside press when trapping focus.
+      mouse: modal === "trap-focus" ? "sloppy" : "intentional",
+      touch: "sloppy"
+    }
+  });
+  const triggerProps = dismiss.reference;
+  const popupProps = dismiss.floating;
+  usePopupInteractionProps(store, {
+    activeTriggerProps: triggerProps,
+    inactiveTriggerProps: triggerProps,
+    popupProps
+  });
+  return null;
+}
+const OPEN_DELAY = 300;
+const PopoverTrigger = fastComponentRef(function PopoverTrigger2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    disabled = false,
+    nativeButton = true,
+    handle,
+    payload,
+    openOnHover = false,
+    delay = OPEN_DELAY,
+    closeDelay = 0,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const rootStore = usePopoverRootContext(true);
+  const handleStore = usePopupHandleStore(handle);
+  const store = handleStore ?? rootStore;
+  if (!store) {
+    throw new Error(formatErrorMessage(74));
+  }
+  const thisTriggerId = useBaseUiId(idProp);
+  const isTriggerActive = store.useState("isTriggerActive", thisTriggerId);
+  const floatingContext = store.useState("floatingRootContext");
+  const isOpenedByThisTrigger = store.useState("isOpenedByTrigger", thisTriggerId);
+  const popupId = store.useState("triggerPopupId", thisTriggerId);
+  const triggerElementRef = reactExports.useRef(null);
+  const {
+    registerTrigger,
+    isMountedByThisTrigger
+  } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+    payload,
+    disabled,
+    openOnHover,
+    closeDelay
+  });
+  const openReason = store.useState("openChangeReason");
+  const stickIfOpen = store.useState("stickIfOpen");
+  const openMethod = store.useState("openMethod");
+  const focusManagerModal = store.useState("focusManagerModal");
+  const hoverProps = useHoverReferenceInteraction(floatingContext, {
+    enabled: !disabled && openOnHover && (openMethod !== "touch" || openReason !== triggerPress),
+    mouseOnly: true,
+    move: false,
+    handleClose: safePolygon(),
+    restMs: delay,
+    delay: {
+      close: closeDelay
+    },
+    triggerElementRef,
+    isActiveTrigger: isTriggerActive,
+    isClosing: () => store.select("transitionStatus") === "ending"
+  });
+  const click = useClick(floatingContext, {
+    stickIfOpen
+  });
+  const interactionTypeProps = useOpenMethodTriggerProps(() => store.select("open"), (interactionType) => {
+    store.set("openMethod", interactionType);
+  });
+  const rootTriggerProps = store.useState("triggerProps", isMountedByThisTrigger);
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const stateAttributesMapping = {
+    open(value) {
+      if (value && openReason === triggerPress) {
+        return pressableTriggerOpenStateMapping.open(value);
+      }
+      return triggerOpenStateMapping.open(value);
+    }
+  };
+  const {
+    preFocusGuardRef,
+    handlePreFocusGuardFocus,
+    handleFocusTargetFocus
+  } = useTriggerFocusGuards(store, triggerElementRef);
+  const state = {
+    disabled,
+    open: isOpenedByThisTrigger
+  };
+  const element = useRenderElement("button", componentProps, {
+    state,
+    ref: [buttonRef, forwardedRef, registerTrigger, triggerElementRef],
+    props: [click.reference, hoverProps, rootTriggerProps, interactionTypeProps, {
+      [CLICK_TRIGGER_IDENTIFIER]: "",
+      id: thisTriggerId,
+      "aria-haspopup": "dialog",
+      "aria-expanded": isOpenedByThisTrigger,
+      "aria-controls": popupId
+    }, elementProps, getButtonProps],
+    stateAttributesMapping
+  });
+  const keyedElement = /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Fragment, {
+    children: element
+  }, thisTriggerId);
+  if (isMountedByThisTrigger && !focusManagerModal) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(reactExports.Fragment, {
+      children: [/* @__PURE__ */ jsxRuntimeExports.jsx(FocusGuard, {
+        ref: preFocusGuardRef,
+        onFocus: handlePreFocusGuardFocus
+      }), keyedElement, /* @__PURE__ */ jsxRuntimeExports.jsx(FocusGuard, {
+        ref: store.context.triggerFocusTargetRef,
+        onFocus: handleFocusTargetFocus
+      })]
+    });
+  }
+  return keyedElement;
+});
+const PopoverPortalContext = /* @__PURE__ */ reactExports.createContext(void 0);
+function usePopoverPortalContext() {
+  const value = reactExports.useContext(PopoverPortalContext);
+  if (value === void 0) {
+    throw new Error(formatErrorMessage(45));
+  }
+  return value;
+}
+const PopoverPortal = /* @__PURE__ */ reactExports.forwardRef(function PopoverPortal2(props, forwardedRef) {
+  const {
+    keepMounted = false,
+    ...portalProps
+  } = props;
+  const store = usePopoverRootContext();
+  const mounted = store.useState("mounted");
+  const shouldRender = mounted || keepMounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(PopoverPortalContext.Provider, {
+    value: keepMounted,
+    children: /* @__PURE__ */ jsxRuntimeExports.jsx(FloatingPortal, {
+      ref: forwardedRef,
+      ...portalProps
+    })
+  });
+});
+const PopoverPositionerContext = /* @__PURE__ */ reactExports.createContext(void 0);
+function usePopoverPositionerContext() {
+  const context = reactExports.useContext(PopoverPositionerContext);
+  if (!context) {
+    throw new Error(formatErrorMessage(46));
+  }
+  return context;
+}
+const PopoverPositioner = /* @__PURE__ */ reactExports.forwardRef(function PopoverPositioner2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    anchor,
+    // `useAnchorPositioning` applies the same defaults to the undefined values; the names
+    // remain destructured to exclude the props from `elementProps`.
+    positionMethod,
+    side,
+    align,
+    sideOffset,
+    alignOffset,
+    collisionBoundary = "clipping-ancestors",
+    collisionPadding,
+    arrowPadding,
+    sticky,
+    disableAnchorTracking = false,
+    collisionAvoidance = POPUP_COLLISION_AVOIDANCE,
+    ...elementProps
+  } = componentProps;
+  const store = usePopoverRootContext();
+  const keepMounted = usePopoverPortalContext();
+  const nodeId = useFloatingNodeId();
+  const floatingRootContext = store.useState("floatingRootContext");
+  const mounted = store.useState("mounted");
+  const open = store.useState("open");
+  const openReason = store.useState("openChangeReason");
+  const triggerElement = store.useState("activeTriggerElement");
+  const modal = store.useState("modal");
+  const openMethod = store.useState("openMethod");
+  const positionerElement = store.useState("positionerElement");
+  const instantType = store.useState("instantType");
+  const transitionStatus = store.useState("transitionStatus");
+  const adaptiveOrigin = store.useState("adaptiveOrigin");
+  const prevTriggerElementRef = reactExports.useRef(null);
+  const runOnceAnimationsFinish = useAnimationsFinished(positionerElement);
+  const positioning = useAnchorPositioning({
+    anchor,
+    floatingRootContext,
+    positionMethod,
+    mounted,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    arrowPadding,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    disableAnchorTracking,
+    keepMounted,
+    nodeId,
+    collisionAvoidance,
+    adaptiveOrigin
+  });
+  const domReference = floatingRootContext.useState("domReferenceElement");
+  useIsoLayoutEffect(() => {
+    const currentTriggerElement = domReference;
+    const prevTriggerElement = prevTriggerElementRef.current;
+    if (currentTriggerElement) {
+      prevTriggerElementRef.current = currentTriggerElement;
+    }
+    if (prevTriggerElement && currentTriggerElement && currentTriggerElement !== prevTriggerElement) {
+      store.set("instantType", void 0);
+      const ac = new AbortController();
+      runOnceAnimationsFinish(() => {
+        store.set("instantType", "trigger-change");
+      }, ac.signal);
+      return () => {
+        ac.abort();
+      };
+    }
+    return void 0;
+  }, [domReference, runOnceAnimationsFinish, store]);
+  const trueModalNonHover = modal === true && openReason !== triggerHover;
+  useAnchoredPopupScrollLock(open && trueModalNonHover, openMethod === "touch", positionerElement, triggerElement);
+  const setPositionerElement = store.useStateSetter("positionerElement");
+  const state = {
+    open,
+    side: positioning.side,
+    align: positioning.align,
+    anchorHidden: positioning.anchorHidden,
+    instant: instantType
+  };
+  const element = usePositioner(componentProps, state, {
+    styles: positioning.positionerStyles,
+    transitionStatus,
+    props: elementProps,
+    refs: [forwardedRef, setPositionerElement],
+    hidden: !mounted,
+    inert: !open
+  });
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(PopoverPositionerContext.Provider, {
+    value: positioning,
+    children: [mounted && trueModalNonHover && /* @__PURE__ */ jsxRuntimeExports.jsx(InternalBackdrop, {
+      inert: inertValue(!open),
+      cutout: triggerElement
+    }), /* @__PURE__ */ jsxRuntimeExports.jsx(FloatingNode, {
+      id: nodeId,
+      children: element
+    })]
+  });
+});
+const ClosePartContext = /* @__PURE__ */ reactExports.createContext(void 0);
+function useClosePartCount() {
+  const [closePartCount, setClosePartCount] = reactExports.useState(0);
+  const register = useStableCallback(() => {
+    setClosePartCount((count) => count + 1);
+    return () => {
+      setClosePartCount((count) => Math.max(0, count - 1));
+    };
+  });
+  const context = reactExports.useMemo(() => ({
+    register
+  }), [register]);
+  return {
+    context,
+    hasClosePart: closePartCount > 0
+  };
+}
+function useClosePartRegistration() {
+  const context = reactExports.useContext(ClosePartContext);
+  useIsoLayoutEffect(() => {
+    return context?.register();
+  }, [context]);
+}
+const PopoverPopup = /* @__PURE__ */ reactExports.forwardRef(function PopoverPopup2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    initialFocus,
+    finalFocus,
+    ...elementProps
+  } = componentProps;
+  const store = usePopoverRootContext();
+  const positioner = usePopoverPositionerContext();
+  const insideToolbar = useToolbarRootContext() != null;
+  const {
+    context: closePartContext,
+    hasClosePart
+  } = useClosePartCount();
+  const open = store.useState("open");
+  const openMethod = store.useState("openMethod");
+  const instantType = store.useState("instantType");
+  const transitionStatus = store.useState("transitionStatus");
+  const popupProps = store.useState("popupProps");
+  const titleId = store.useState("titleElementId");
+  const descriptionId = store.useState("descriptionElementId");
+  const modal = store.useState("modal");
+  const mounted = store.useState("mounted");
+  const openReason = store.useState("openChangeReason");
+  const activeTriggerElement = store.useState("activeTriggerElement");
+  const floatingContext = store.useState("floatingRootContext");
+  const floatingId = floatingContext.useState("floatingId");
+  const disabled = store.useState("disabled");
+  const openOnHover = store.useState("openOnHover");
+  const closeDelay = store.useState("closeDelay");
+  useOpenChangeComplete({
+    open,
+    ref: store.context.popupRef,
+    onComplete() {
+      if (open) {
+        store.context.onOpenChangeComplete?.(true);
+      }
+    }
+  });
+  useHoverFloatingInteraction(floatingContext, {
+    enabled: openOnHover && !disabled,
+    closeDelay
+  });
+  const resolvedInitialFocus = initialFocus === void 0 ? createDefaultInitialFocus(store.context.popupRef) : initialFocus;
+  const focusManagerModal = modal !== false && hasClosePart;
+  store.useSyncedValue("focusManagerModal", focusManagerModal);
+  const setPopupElement = store.useStateSetter("popupElement");
+  const state = {
+    open,
+    side: positioner.side,
+    align: positioner.align,
+    instant: instantType,
+    transitionStatus
+  };
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, store.context.popupRef, setPopupElement],
+    props: [popupProps, {
+      id: floatingId,
+      role: "dialog",
+      ...FOCUSABLE_POPUP_PROPS,
+      "aria-labelledby": titleId,
+      "aria-describedby": descriptionId,
+      onKeyDown(event) {
+        if (insideToolbar && COMPOSITE_KEYS.has(event.key)) {
+          event.stopPropagation();
+        }
+      }
+    }, getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    stateAttributesMapping: popupTransitionStateMapping
+  });
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(FloatingFocusManager, {
+    context: floatingContext,
+    openInteractionType: openMethod,
+    modal: focusManagerModal,
+    disabled: !mounted || openReason === triggerHover,
+    initialFocus: resolvedInitialFocus,
+    returnFocus: finalFocus,
+    restoreFocus: "popup",
+    previousFocusableElement: isHTMLElement(activeTriggerElement) ? activeTriggerElement : void 0,
+    nextFocusableElement: store.context.triggerFocusTargetRef,
+    beforeContentFocusGuardRef: store.context.beforeContentFocusGuardRef,
+    children: /* @__PURE__ */ jsxRuntimeExports.jsx(ClosePartContext.Provider, {
+      value: closePartContext,
+      children: element
+    })
+  });
+});
+export {
+  PopoverRoot as P,
+  Settings2 as S,
+  useClosePartRegistration as a,
+  PopoverTrigger as b,
+  PopoverPortal as c,
+  PopoverPositioner as d,
+  PopoverPopup as e,
+  usePopoverRootContext as u
+};

package/out/renderer/assets/{_baseUniq-BdLqGxOi.js → _baseUniq-KD2XGr9F.js}

@@ -1,4 +1,4 @@
-import { b1 as isObjectLike, br as baseGetTag, aL as isArray, a$ as Symbol$1, aK as isArrayLike, bs as arrayLikeKeys, bt as baseKeys, bu as memoize, bv as isArguments, bw as MapCache, bx as eq, by as Uint8Array, b2 as getTag, b7 as isBuffer, ba as Stack, bz as isTypedArray, b5 as isObject, bA as isLength, bB as isIndex, aM as identity, bC as baseFor, bD as Set } from "./mermaid-HWGCJPDP-BufLuIVq.js";
+import { b1 as isObjectLike, br as baseGetTag, aL as isArray, a$ as Symbol$1, aK as isArrayLike, bs as arrayLikeKeys, bt as baseKeys, bu as memoize, bv as isArguments, bw as MapCache, bx as eq, by as Uint8Array, b2 as getTag, b7 as isBuffer, ba as Stack, bz as isTypedArray, b5 as isObject, bA as isLength, bB as isIndex, aM as identity, bC as baseFor, bD as Set } from "./mermaid-HWGCJPDP-OB5tfzeR.js";
 var symbolTag$1 = "[object Symbol]";
 function isSymbol(value) {
   return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$1;

package/out/renderer/assets/{arc-UpL8po5R.js → arc-CR7wDdln.js}

@@ -1,4 +1,4 @@
-import { P as withPath, Q as pi, R as cos, T as sin, V as constant, W as halfPi, X as epsilon, Y as tau, Z as sqrt, $ as min, a0 as abs, a1 as atan2, a2 as max, a3 as asin, a4 as acos } from "./mermaid-HWGCJPDP-BufLuIVq.js";
+import { P as withPath, Q as pi, R as cos, T as sin, V as constant, W as halfPi, X as epsilon, Y as tau, Z as sqrt, $ as min, a0 as abs, a1 as atan2, a2 as max, a3 as asin, a4 as acos } from "./mermaid-HWGCJPDP-OB5tfzeR.js";
 function arcInnerRadius(d) {
   return d.innerRadius;
 }

package/out/renderer/assets/{architectureDiagram-Q4EWVU46-ManEkEbl.js → architectureDiagram-Q4EWVU46-ob7rXg_N.js}

@@ -1,10 +1,10 @@
-import { _ as __name, O as selectSvgElement, aj as setupGraphViewbox, l as log, d as setAccTitle, b as getAccTitle, t as setDiagramTitle, v as getDiagramTitle, g as getAccDescription, s as setAccDescription, B as clear, I as cleanAndMerge, K as defaultConfig_default, G as getConfig, e as getConfig2, aq as createText, aN as getIconSVG, k as sanitizeText, f as select, z as getEdgeId, aO as registerIconPacks, aP as unknownIcon } from "./mermaid-HWGCJPDP-BufLuIVq.js";
-import { p as populateCommonDb } from "./chunk-4BX2VUAB-BCKz1EgZ.js";
-import { p as parse } from "./wardley-RL74JXVD-BCH2vKnv.js";
+import { _ as __name, O as selectSvgElement, aj as setupGraphViewbox, l as log, d as setAccTitle, b as getAccTitle, t as setDiagramTitle, v as getDiagramTitle, g as getAccDescription, s as setAccDescription, B as clear, L as cleanAndMerge, M as defaultConfig_default, I as getConfig, e as getConfig2, aq as createText, aN as getIconSVG, k as sanitizeText, f as select, z as getEdgeId, aO as registerIconPacks, aP as unknownIcon } from "./mermaid-HWGCJPDP-OB5tfzeR.js";
+import { p as populateCommonDb } from "./chunk-4BX2VUAB-0jn0O1rt.js";
+import { p as parse } from "./wardley-RL74JXVD-2Xd7XlwA.js";
 import { c as cytoscape$1 } from "./cytoscape.esm-Bm8DJGmZ.js";
-import { ar as getDefaultExportFromCjs } from "./index-BeEZXfJZ.js";
-import "./min-BCqStlR1.js";
-import "./_baseUniq-BdLqGxOi.js";
+import { ax as getDefaultExportFromCjs } from "./index-CKDwIiIb.js";
+import "./min-lM3sC06g.js";
+import "./_baseUniq-KD2XGr9F.js";
 var cytoscapeFcose$1 = { exports: {} };
 var coseBase$1 = { exports: {} };
 var layoutBase$1 = { exports: {} };

package/out/renderer/assets/{arrow-left-BnuWerui.js → arrow-left-Ck_ZVJr5.js}

@@ -1,4 +1,4 @@
-import { c as createLucideIcon } from "./index-BeEZXfJZ.js";
+import { c as createLucideIcon } from "./index-CKDwIiIb.js";
 const __iconData = {
   name: "arrow-left",
   size: 24,

package/out/renderer/assets/{arrow-up-quD46bYg.js → arrow-up-D7cOrlYE.js}

@@ -1,5 +1,5 @@
-import { c as createLucideIcon } from "./index-BeEZXfJZ.js";
-const __iconData$2 = {
+import { c as createLucideIcon } from "./index-CKDwIiIb.js";
+const __iconData$1 = {
   name: "arrow-down",
   size: 24,
   node: [
@@ -7,18 +7,8 @@ const __iconData$2 = {
     ["path", { d: "m19 12-7 7-7-7", key: "1idqje" }]
   ]
 };
-__iconData$2.node;
-const ArrowDown = createLucideIcon(__iconData$2);
-const __iconData$1 = {
-  name: "arrow-right",
-  size: 24,
-  node: [
-    ["path", { d: "M5 12h14", key: "1ays0h" }],
-    ["path", { d: "m12 5 7 7-7 7", key: "xquz4c" }]
-  ]
-};
 __iconData$1.node;
-const ArrowRight = createLucideIcon(__iconData$1);
+const ArrowDown = createLucideIcon(__iconData$1);
 const __iconData = {
   name: "arrow-up",
   size: 24,
@@ -31,6 +21,5 @@ __iconData.node;
 const ArrowUp = createLucideIcon(__iconData);
 export {
   ArrowUp as A,
-  ArrowDown as a,
-  ArrowRight as b
+  ArrowDown as a
 };