refactor: split web frontend + gateway out to uniweb app (bump 0.13.0)

The SPA (web/) and the web gateway (cmd/webgw) move to a dedicated app
projects/message_bus/apps/uniweb (its own Gitea sub-repo). unibus is now
strictly the bus plane: membership/keys, the client library and demo peers.
uniweb consumes unibus as a Go module via replace => ../unibus.

No capability lost; same SPA and gateway, in their own service folder.
go build/vet/test green after extraction.

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Vitaly Rtishchev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/README.md

@@ -0,0 +1,21 @@
+# Mantine Hooks
+
+[![npm](https://img.shields.io/npm/dm/@mantine/hooks)](https://www.npmjs.com/package/@mantine/hooks)
+
+A set of react hooks for state and UI management
+
+[View documentation](https://mantine.dev/)
+
+## Installation
+
+```bash
+# With yarn
+yarn add @mantine/hooks
+
+# With npm
+npm install @mantine/hooks
+```
+
+## License
+
+MIT

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/index.cjs

@@ -0,0 +1,195 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_clamp = require("./utils/clamp/clamp.cjs");
+const require_lower_first = require("./utils/lower-first/lower-first.cjs");
+const require_random_id = require("./utils/random-id/random-id.cjs");
+const require_range = require("./utils/range/range.cjs");
+const require_shallow_equal = require("./utils/shallow-equal/shallow-equal.cjs");
+const require_upper_first = require("./utils/upper-first/upper-first.cjs");
+const require_use_callback_ref = require("./utils/use-callback-ref/use-callback-ref.cjs");
+const require_use_debounced_callback = require("./use-debounced-callback/use-debounced-callback.cjs");
+const require_use_click_outside = require("./use-click-outside/use-click-outside.cjs");
+const require_use_clipboard = require("./use-clipboard/use-clipboard.cjs");
+const require_use_media_query = require("./use-media-query/use-media-query.cjs");
+const require_use_color_scheme = require("./use-color-scheme/use-color-scheme.cjs");
+const require_use_counter = require("./use-counter/use-counter.cjs");
+const require_use_debounced_state = require("./use-debounced-state/use-debounced-state.cjs");
+const require_use_debounced_value = require("./use-debounced-value/use-debounced-value.cjs");
+const require_use_isomorphic_effect = require("./use-isomorphic-effect/use-isomorphic-effect.cjs");
+const require_use_document_title = require("./use-document-title/use-document-title.cjs");
+const require_use_document_visibility = require("./use-document-visibility/use-document-visibility.cjs");
+const require_use_did_update = require("./use-did-update/use-did-update.cjs");
+const require_use_focus_return = require("./use-focus-return/use-focus-return.cjs");
+const require_use_focus_trap = require("./use-focus-trap/use-focus-trap.cjs");
+const require_use_force_update = require("./use-force-update/use-force-update.cjs");
+const require_use_id = require("./use-id/use-id.cjs");
+const require_use_idle = require("./use-idle/use-idle.cjs");
+const require_use_interval = require("./use-interval/use-interval.cjs");
+const require_use_list_state = require("./use-list-state/use-list-state.cjs");
+const require_use_window_event = require("./use-window-event/use-window-event.cjs");
+const require_use_local_storage = require("./use-local-storage/use-local-storage.cjs");
+const require_use_session_storage = require("./use-session-storage/use-session-storage.cjs");
+const require_use_merged_ref = require("./use-merged-ref/use-merged-ref.cjs");
+const require_use_mouse = require("./use-mouse/use-mouse.cjs");
+const require_use_move = require("./use-move/use-move.cjs");
+const require_use_uncontrolled = require("./use-uncontrolled/use-uncontrolled.cjs");
+const require_use_pagination = require("./use-pagination/use-pagination.cjs");
+const require_use_queue = require("./use-queue/use-queue.cjs");
+const require_use_page_leave = require("./use-page-leave/use-page-leave.cjs");
+const require_use_reduced_motion = require("./use-reduced-motion/use-reduced-motion.cjs");
+const require_use_scroll_into_view = require("./use-scroll-into-view/use-scroll-into-view.cjs");
+const require_use_resize_observer = require("./use-resize-observer/use-resize-observer.cjs");
+const require_use_shallow_effect = require("./use-shallow-effect/use-shallow-effect.cjs");
+const require_use_toggle = require("./use-toggle/use-toggle.cjs");
+const require_use_viewport_size = require("./use-viewport-size/use-viewport-size.cjs");
+const require_use_window_scroll = require("./use-window-scroll/use-window-scroll.cjs");
+const require_use_intersection = require("./use-intersection/use-intersection.cjs");
+const require_use_hash = require("./use-hash/use-hash.cjs");
+const require_parse_hotkey = require("./use-hotkeys/parse-hotkey.cjs");
+const require_use_hotkeys = require("./use-hotkeys/use-hotkeys.cjs");
+const require_use_fullscreen = require("./use-fullscreen/use-fullscreen.cjs");
+const require_use_logger = require("./use-logger/use-logger.cjs");
+const require_use_hover = require("./use-hover/use-hover.cjs");
+const require_use_validated_state = require("./use-validated-state/use-validated-state.cjs");
+const require_use_os = require("./use-os/use-os.cjs");
+const require_use_set_state = require("./use-set-state/use-set-state.cjs");
+const require_use_input_state = require("./use-input-state/use-input-state.cjs");
+const require_use_event_listener = require("./use-event-listener/use-event-listener.cjs");
+const require_use_disclosure = require("./use-disclosure/use-disclosure.cjs");
+const require_use_focus_within = require("./use-focus-within/use-focus-within.cjs");
+const require_use_network = require("./use-network/use-network.cjs");
+const require_use_timeout = require("./use-timeout/use-timeout.cjs");
+const require_use_text_selection = require("./use-text-selection/use-text-selection.cjs");
+const require_use_previous = require("./use-previous/use-previous.cjs");
+const require_use_favicon = require("./use-favicon/use-favicon.cjs");
+const require_use_scroll_direction = require("./use-scroll-direction/use-scroll-direction.cjs");
+const require_use_headroom = require("./use-headroom/use-headroom.cjs");
+const require_use_eye_dropper = require("./use-eye-dropper/use-eye-dropper.cjs");
+const require_use_in_viewport = require("./use-in-viewport/use-in-viewport.cjs");
+const require_use_mutation_observer = require("./use-mutation-observer/use-mutation-observer.cjs");
+const require_use_mounted = require("./use-mounted/use-mounted.cjs");
+const require_use_state_history = require("./use-state-history/use-state-history.cjs");
+const require_use_map = require("./use-map/use-map.cjs");
+const require_use_set = require("./use-set/use-set.cjs");
+const require_use_throttled_callback = require("./use-throttled-callback/use-throttled-callback.cjs");
+const require_use_throttled_state = require("./use-throttled-state/use-throttled-state.cjs");
+const require_use_throttled_value = require("./use-throttled-value/use-throttled-value.cjs");
+const require_use_is_first_render = require("./use-is-first-render/use-is-first-render.cjs");
+const require_use_orientation = require("./use-orientation/use-orientation.cjs");
+const require_use_fetch = require("./use-fetch/use-fetch.cjs");
+const require_use_radial_move = require("./use-radial-move/use-radial-move.cjs");
+const require_use_scroll_spy = require("./use-scroll-spy/use-scroll-spy.cjs");
+const require_use_scroller = require("./use-scroller/use-scroller.cjs");
+const require_use_file_dialog = require("./use-file-dialog/use-file-dialog.cjs");
+const require_use_long_press = require("./use-long-press/use-long-press.cjs");
+const require_use_selection = require("./use-selection/use-selection.cjs");
+const require_use_floating_window = require("./use-floating-window/use-floating-window.cjs");
+const require_use_collapse = require("./use-collapse/use-collapse.cjs");
+const require_use_horizontal_collapse = require("./use-collapse/use-horizontal-collapse.cjs");
+const require_use_mask = require("./use-mask/use-mask.cjs");
+const require_use_roving_index = require("./use-roving-index/use-roving-index.cjs");
+const require_use_drag = require("./use-drag/use-drag.cjs");
+const require_use_splitter = require("./use-splitter/use-splitter.cjs");
+exports.assignRef = require_use_merged_ref.assignRef;
+exports.clamp = require_clamp.clamp;
+exports.clampUseMovePosition = require_use_move.clampUseMovePosition;
+exports.formatMask = require_use_mask.formatMask;
+exports.generatePattern = require_use_mask.generatePattern;
+exports.getHotkeyHandler = require_parse_hotkey.getHotkeyHandler;
+exports.isMaskComplete = require_use_mask.isMaskComplete;
+exports.lowerFirst = require_lower_first.lowerFirst;
+exports.mergeRefs = require_use_merged_ref.mergeRefs;
+exports.normalizeRadialValue = require_use_radial_move.normalizeRadialValue;
+exports.randomId = require_random_id.randomId;
+exports.range = require_range.range;
+exports.readLocalStorageValue = require_use_local_storage.readLocalStorageValue;
+exports.readSessionStorageValue = require_use_session_storage.readSessionStorageValue;
+exports.shallowEqual = require_shallow_equal.shallowEqual;
+exports.unformatMask = require_use_mask.unformatMask;
+exports.upperFirst = require_upper_first.upperFirst;
+exports.useCallbackRef = require_use_callback_ref.useCallbackRef;
+exports.useClickOutside = require_use_click_outside.useClickOutside;
+exports.useClipboard = require_use_clipboard.useClipboard;
+exports.useCollapse = require_use_collapse.useCollapse;
+exports.useColorScheme = require_use_color_scheme.useColorScheme;
+exports.useCounter = require_use_counter.useCounter;
+exports.useDebouncedCallback = require_use_debounced_callback.useDebouncedCallback;
+exports.useDebouncedState = require_use_debounced_state.useDebouncedState;
+exports.useDebouncedValue = require_use_debounced_value.useDebouncedValue;
+exports.useDidUpdate = require_use_did_update.useDidUpdate;
+exports.useDisclosure = require_use_disclosure.useDisclosure;
+exports.useDocumentTitle = require_use_document_title.useDocumentTitle;
+exports.useDocumentVisibility = require_use_document_visibility.useDocumentVisibility;
+exports.useDrag = require_use_drag.useDrag;
+exports.useElementSize = require_use_resize_observer.useElementSize;
+exports.useEventListener = require_use_event_listener.useEventListener;
+exports.useEyeDropper = require_use_eye_dropper.useEyeDropper;
+exports.useFavicon = require_use_favicon.useFavicon;
+exports.useFetch = require_use_fetch.useFetch;
+exports.useFileDialog = require_use_file_dialog.useFileDialog;
+exports.useFloatingWindow = require_use_floating_window.useFloatingWindow;
+exports.useFocusReturn = require_use_focus_return.useFocusReturn;
+exports.useFocusTrap = require_use_focus_trap.useFocusTrap;
+exports.useFocusWithin = require_use_focus_within.useFocusWithin;
+exports.useForceUpdate = require_use_force_update.useForceUpdate;
+exports.useFullscreenDocument = require_use_fullscreen.useFullscreenDocument;
+exports.useFullscreenElement = require_use_fullscreen.useFullscreenElement;
+exports.useHash = require_use_hash.useHash;
+exports.useHeadroom = require_use_headroom.useHeadroom;
+exports.useHorizontalCollapse = require_use_horizontal_collapse.useHorizontalCollapse;
+exports.useHotkeys = require_use_hotkeys.useHotkeys;
+exports.useHover = require_use_hover.useHover;
+exports.useId = require_use_id.useId;
+exports.useIdle = require_use_idle.useIdle;
+exports.useInViewport = require_use_in_viewport.useInViewport;
+exports.useInputState = require_use_input_state.useInputState;
+exports.useIntersection = require_use_intersection.useIntersection;
+exports.useInterval = require_use_interval.useInterval;
+exports.useIsFirstRender = require_use_is_first_render.useIsFirstRender;
+exports.useIsomorphicEffect = require_use_isomorphic_effect.useIsomorphicEffect;
+exports.useListState = require_use_list_state.useListState;
+exports.useLocalStorage = require_use_local_storage.useLocalStorage;
+exports.useLogger = require_use_logger.useLogger;
+exports.useLongPress = require_use_long_press.useLongPress;
+exports.useMap = require_use_map.useMap;
+exports.useMask = require_use_mask.useMask;
+exports.useMediaQuery = require_use_media_query.useMediaQuery;
+exports.useMergedRef = require_use_merged_ref.useMergedRef;
+exports.useMounted = require_use_mounted.useMounted;
+exports.useMouse = require_use_mouse.useMouse;
+exports.useMousePosition = require_use_mouse.useMousePosition;
+exports.useMove = require_use_move.useMove;
+exports.useMutationObserver = require_use_mutation_observer.useMutationObserver;
+exports.useMutationObserverTarget = require_use_mutation_observer.useMutationObserverTarget;
+exports.useNetwork = require_use_network.useNetwork;
+exports.useOrientation = require_use_orientation.useOrientation;
+exports.useOs = require_use_os.useOs;
+exports.usePageLeave = require_use_page_leave.usePageLeave;
+exports.usePagination = require_use_pagination.usePagination;
+exports.usePrevious = require_use_previous.usePrevious;
+exports.useQueue = require_use_queue.useQueue;
+exports.useRadialMove = require_use_radial_move.useRadialMove;
+exports.useReducedMotion = require_use_reduced_motion.useReducedMotion;
+exports.useResizeObserver = require_use_resize_observer.useResizeObserver;
+exports.useRovingIndex = require_use_roving_index.useRovingIndex;
+exports.useScrollDirection = require_use_scroll_direction.useScrollDirection;
+exports.useScrollIntoView = require_use_scroll_into_view.useScrollIntoView;
+exports.useScrollSpy = require_use_scroll_spy.useScrollSpy;
+exports.useScroller = require_use_scroller.useScroller;
+exports.useSelection = require_use_selection.useSelection;
+exports.useSessionStorage = require_use_session_storage.useSessionStorage;
+exports.useSet = require_use_set.useSet;
+exports.useSetState = require_use_set_state.useSetState;
+exports.useShallowEffect = require_use_shallow_effect.useShallowEffect;
+exports.useSplitter = require_use_splitter.useSplitter;
+exports.useStateHistory = require_use_state_history.useStateHistory;
+exports.useTextSelection = require_use_text_selection.useTextSelection;
+exports.useThrottledCallback = require_use_throttled_callback.useThrottledCallback;
+exports.useThrottledState = require_use_throttled_state.useThrottledState;
+exports.useThrottledValue = require_use_throttled_value.useThrottledValue;
+exports.useTimeout = require_use_timeout.useTimeout;
+exports.useToggle = require_use_toggle.useToggle;
+exports.useUncontrolled = require_use_uncontrolled.useUncontrolled;
+exports.useValidatedState = require_use_validated_state.useValidatedState;
+exports.useViewportSize = require_use_viewport_size.useViewportSize;
+exports.useWindowEvent = require_use_window_event.useWindowEvent;
+exports.useWindowScroll = require_use_window_scroll.useWindowScroll;

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-click-outside/use-click-outside.cjs

@@ -0,0 +1,29 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-click-outside/use-click-outside.ts
+const DEFAULT_EVENTS = ["mousedown", "touchstart"];
+function useClickOutside(callback, events, nodes, enabled = true) {
+	const ref = (0, react.useRef)(null);
+	const eventsList = events || DEFAULT_EVENTS;
+	const listener = (0, react.useEffectEvent)((event) => {
+		const { target } = event ?? {};
+		if (!document.body.contains(target) && target?.tagName !== "HTML") return;
+		const path = event.composedPath();
+		if (Array.isArray(nodes)) nodes.every((node) => !!node && !path.includes(node)) && callback(event);
+		else if (ref.current && !path.includes(ref.current)) callback(event);
+	});
+	const eventsKey = eventsList.join(",");
+	(0, react.useEffect)(() => {
+		if (!enabled) return;
+		const events = eventsKey.split(",");
+		events.forEach((fn) => document.addEventListener(fn, listener));
+		return () => {
+			events.forEach((fn) => document.removeEventListener(fn, listener));
+		};
+	}, [eventsKey, enabled]);
+	return ref;
+}
+//#endregion
+exports.useClickOutside = useClickOutside;
+
+//# sourceMappingURL=use-click-outside.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-click-outside/use-click-outside.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-click-outside.cjs","names":[],"sources":["../../src/use-click-outside/use-click-outside.ts"],"sourcesContent":["import { useEffect, useEffectEvent, useRef } from 'react';\n\ntype EventType = MouseEvent | TouchEvent;\n\nconst DEFAULT_EVENTS = ['mousedown', 'touchstart'];\n\nexport function useClickOutside<T extends HTMLElement = any>(\n  callback: (event: EventType) => void,\n  events?: string[] | null,\n  nodes?: (HTMLElement | null)[],\n  enabled: boolean = true\n) {\n  const ref = useRef<T>(null);\n  const eventsList = events || DEFAULT_EVENTS;\n\n  const listener = useEffectEvent((event: Event) => {\n    const { target } = event ?? {};\n    const shouldIgnore =\n      !document.body.contains(target as Node) && (target as Element)?.tagName !== 'HTML';\n\n    if (shouldIgnore) {\n      return;\n    }\n\n    const path = event.composedPath();\n\n    if (Array.isArray(nodes)) {\n      const shouldTrigger = nodes.every((node) => !!node && !path.includes(node));\n      shouldTrigger && callback(event as EventType);\n    } else if (ref.current && !path.includes(ref.current)) {\n      callback(event as EventType);\n    }\n  });\n\n  const eventsKey = eventsList.join(',');\n\n  useEffect(() => {\n    if (!enabled) {\n      return undefined;\n    }\n\n    const events = eventsKey.split(',');\n    events.forEach((fn) => document.addEventListener(fn, listener));\n\n    return () => {\n      events.forEach((fn) => document.removeEventListener(fn, listener));\n    };\n  }, [eventsKey, enabled]);\n\n  return ref;\n}\n"],"mappings":";;;AAIA,MAAM,iBAAiB,CAAC,aAAa,YAAY;AAEjD,SAAgB,gBACd,UACA,QACA,OACA,UAAmB,MACnB;CACA,MAAM,OAAA,GAAA,MAAA,QAAgB,IAAI;CAC1B,MAAM,aAAa,UAAU;CAE7B,MAAM,YAAA,GAAA,MAAA,iBAA2B,UAAiB;EAChD,MAAM,EAAE,WAAW,SAAS,CAAC;EAI7B,IAFE,CAAC,SAAS,KAAK,SAAS,MAAc,KAAM,QAAoB,YAAY,QAG5E;EAGF,MAAM,OAAO,MAAM,aAAa;EAEhC,IAAI,MAAM,QAAQ,KAAK,GAErB,MAD4B,OAAO,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAK,SAAS,IAAI,CAC7D,KAAK,SAAS,KAAkB;OACvC,IAAI,IAAI,WAAW,CAAC,KAAK,SAAS,IAAI,OAAO,GAClD,SAAS,KAAkB;CAE/B,CAAC;CAED,MAAM,YAAY,WAAW,KAAK,GAAG;CAErC,CAAA,GAAA,MAAA,iBAAgB;EACd,IAAI,CAAC,SACH;EAGF,MAAM,SAAS,UAAU,MAAM,GAAG;EAClC,OAAO,SAAS,OAAO,SAAS,iBAAiB,IAAI,QAAQ,CAAC;EAE9D,aAAa;GACX,OAAO,SAAS,OAAO,SAAS,oBAAoB,IAAI,QAAQ,CAAC;EACnE;CACF,GAAG,CAAC,WAAW,OAAO,CAAC;CAEvB,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-clipboard/use-clipboard.cjs

@@ -0,0 +1,39 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-clipboard/use-clipboard.ts
+function useClipboard(options = {}) {
+	const timeout = options.timeout ?? 2e3;
+	const [error, setError] = (0, react.useState)(null);
+	const [copied, setCopied] = (0, react.useState)(false);
+	const timeoutRef = (0, react.useRef)(null);
+	(0, react.useEffect)(() => () => {
+		window.clearTimeout(timeoutRef.current);
+	}, []);
+	const handleCopyResult = (value) => {
+		window.clearTimeout(timeoutRef.current);
+		timeoutRef.current = window.setTimeout(() => setCopied(false), timeout);
+		setCopied(value);
+	};
+	const copy = (value) => {
+		if ("clipboard" in navigator) navigator.clipboard.writeText(value).then(() => {
+			setError(null);
+			handleCopyResult(true);
+		}).catch((err) => setError(err));
+		else setError(/* @__PURE__ */ new Error("useClipboard: navigator.clipboard is not supported"));
+	};
+	const reset = () => {
+		setCopied(false);
+		setError(null);
+		window.clearTimeout(timeoutRef.current);
+	};
+	return {
+		copy,
+		reset,
+		error,
+		copied
+	};
+}
+//#endregion
+exports.useClipboard = useClipboard;
+
+//# sourceMappingURL=use-clipboard.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-clipboard/use-clipboard.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-clipboard.cjs","names":[],"sources":["../../src/use-clipboard/use-clipboard.ts"],"sourcesContent":["import { useEffect, useRef, useState } from 'react';\n\nexport interface UseClipboardInput {\n  /** Time in ms after which the copied state will reset, `2000` by default */\n  timeout?: number;\n}\n\nexport interface UseClipboardReturnValue {\n  /** Function to copy value to clipboard */\n  copy: (value: any) => void;\n\n  /** Function to reset copied state and error */\n  reset: () => void;\n\n  /** Error if copying failed */\n  error: Error | null;\n\n  /** Boolean indicating if the value was copied successfully */\n  copied: boolean;\n}\n\nexport function useClipboard(options: UseClipboardInput = {}): UseClipboardReturnValue {\n  const timeout = options.timeout ?? 2000;\n  const [error, setError] = useState<Error | null>(null);\n  const [copied, setCopied] = useState(false);\n  const timeoutRef = useRef<number | null>(null);\n\n  useEffect(\n    () => () => {\n      window.clearTimeout(timeoutRef.current!);\n    },\n    []\n  );\n\n  const handleCopyResult = (value: boolean) => {\n    window.clearTimeout(timeoutRef.current!);\n    timeoutRef.current = window.setTimeout(() => setCopied(false), timeout);\n    setCopied(value);\n  };\n\n  const copy = (value: any) => {\n    if ('clipboard' in navigator) {\n      navigator.clipboard\n        .writeText(value)\n        .then(() => {\n          setError(null);\n          handleCopyResult(true);\n        })\n        .catch((err) => setError(err));\n    } else {\n      setError(new Error('useClipboard: navigator.clipboard is not supported'));\n    }\n  };\n\n  const reset = () => {\n    setCopied(false);\n    setError(null);\n    window.clearTimeout(timeoutRef.current!);\n  };\n\n  return { copy, reset, error, copied };\n}\n\nexport namespace useClipboard {\n  export type Input = UseClipboardInput;\n  export type ReturnValue = UseClipboardReturnValue;\n}\n"],"mappings":";;;AAqBA,SAAgB,aAAa,UAA6B,CAAC,GAA4B;CACrF,MAAM,UAAU,QAAQ,WAAW;CACnC,MAAM,CAAC,OAAO,aAAA,GAAA,MAAA,UAAmC,IAAI;CACrD,MAAM,CAAC,QAAQ,cAAA,GAAA,MAAA,UAAsB,KAAK;CAC1C,MAAM,cAAA,GAAA,MAAA,QAAmC,IAAI;CAE7C,CAAA,GAAA,MAAA,uBACc;EACV,OAAO,aAAa,WAAW,OAAQ;CACzC,GACA,CAAC,CACH;CAEA,MAAM,oBAAoB,UAAmB;EAC3C,OAAO,aAAa,WAAW,OAAQ;EACvC,WAAW,UAAU,OAAO,iBAAiB,UAAU,KAAK,GAAG,OAAO;EACtE,UAAU,KAAK;CACjB;CAEA,MAAM,QAAQ,UAAe;EAC3B,IAAI,eAAe,WACjB,UAAU,UACP,UAAU,KAAK,EACf,WAAW;GACV,SAAS,IAAI;GACb,iBAAiB,IAAI;EACvB,CAAC,EACA,OAAO,QAAQ,SAAS,GAAG,CAAC;OAE/B,yBAAS,IAAI,MAAM,oDAAoD,CAAC;CAE5E;CAEA,MAAM,cAAc;EAClB,UAAU,KAAK;EACf,SAAS,IAAI;EACb,OAAO,aAAa,WAAW,OAAQ;CACzC;CAEA,OAAO;EAAE;EAAM;EAAO;EAAO;CAAO;AACtC"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-collapse/use-collapse.cjs

@@ -0,0 +1,101 @@
+"use client";
+const require_use_did_update = require("../use-did-update/use-did-update.cjs");
+const require_use_merged_ref = require("../use-merged-ref/use-merged-ref.cjs");
+let react = require("react");
+let react_dom = require("react-dom");
+//#region packages/@mantine/hooks/src/use-collapse/use-collapse.ts
+function getAutoHeightDuration(height) {
+	if (!height || typeof height === "string") return 0;
+	const constant = height / 36;
+	return Math.round((4 + 15 * constant ** .25 + constant / 5) * 10);
+}
+function getElementHeight(elementRef) {
+	return elementRef.current ? elementRef.current.scrollHeight : "auto";
+}
+function useCollapse({ transitionDuration, transitionTimingFunction = "ease", onTransitionEnd, onTransitionStart, expanded, keepMounted }) {
+	const collapsedStyles = {
+		height: 0,
+		overflow: "hidden",
+		...keepMounted ? {} : { display: "none" }
+	};
+	const onTransitionStartEvent = (0, react.useEffectEvent)(() => onTransitionStart?.());
+	const elementRef = (0, react.useRef)(null);
+	const [styles, setStylesRaw] = (0, react.useState)(expanded ? {} : collapsedStyles);
+	const [state, setState] = (0, react.useState)(expanded ? "entered" : "exited");
+	const setStyles = (newStyles) => {
+		(0, react_dom.flushSync)(() => setStylesRaw(newStyles));
+	};
+	const mergeStyles = (newStyles) => {
+		setStyles((oldStyles) => ({
+			...oldStyles,
+			...newStyles
+		}));
+	};
+	const getTransitionStyles = (height) => {
+		const duration = transitionDuration ?? getAutoHeightDuration(height);
+		return { transition: `height ${duration}ms ${transitionTimingFunction}, opacity ${duration}ms ${transitionTimingFunction}` };
+	};
+	require_use_did_update.useDidUpdate(() => {
+		if (transitionDuration !== 0) onTransitionStartEvent();
+		if (expanded) window.requestAnimationFrame(() => {
+			(0, react_dom.flushSync)(() => setState("entering"));
+			mergeStyles({
+				willChange: "height",
+				display: "block",
+				overflow: "hidden"
+			});
+			window.requestAnimationFrame(() => {
+				const height = getElementHeight(elementRef);
+				mergeStyles({
+					...getTransitionStyles(height),
+					height
+				});
+			});
+		});
+		else window.requestAnimationFrame(() => {
+			(0, react_dom.flushSync)(() => setState("exiting"));
+			const height = getElementHeight(elementRef);
+			mergeStyles({
+				...getTransitionStyles(height),
+				willChange: "height",
+				height
+			});
+			window.requestAnimationFrame(() => mergeStyles({
+				height: 0,
+				overflow: "hidden"
+			}));
+		});
+	}, [expanded]);
+	const handleTransitionEnd = (event) => {
+		if (event.target !== elementRef.current || event.propertyName !== "height") return;
+		if (expanded) {
+			const height = getElementHeight(elementRef);
+			if (height === styles.height) setStyles({});
+			else mergeStyles({ height });
+			setState("entered");
+			onTransitionEnd?.();
+		} else if (styles.height === 0) {
+			setStyles(collapsedStyles);
+			setState("exited");
+			onTransitionEnd?.();
+		}
+	};
+	return {
+		state,
+		getCollapseProps: (input) => ({
+			"aria-hidden": !expanded,
+			inert: !expanded,
+			ref: require_use_merged_ref.mergeRefs(elementRef, input?.ref),
+			onTransitionEnd: handleTransitionEnd,
+			style: {
+				boxSizing: "border-box",
+				...input?.style,
+				...styles
+			}
+		})
+	};
+}
+//#endregion
+exports.useCollapse = useCollapse;
+
+//# sourceMappingURL=use-collapse.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-collapse/use-horizontal-collapse.cjs

@@ -0,0 +1,101 @@
+"use client";
+const require_use_did_update = require("../use-did-update/use-did-update.cjs");
+const require_use_merged_ref = require("../use-merged-ref/use-merged-ref.cjs");
+let react = require("react");
+let react_dom = require("react-dom");
+//#region packages/@mantine/hooks/src/use-collapse/use-horizontal-collapse.ts
+function getAutoWidthDuration(width) {
+	if (!width || typeof width === "string") return 0;
+	const constant = width / 36;
+	return Math.round((4 + 15 * constant ** .25 + constant / 5) * 10);
+}
+function getElementWidth(elementRef) {
+	return elementRef.current ? elementRef.current.scrollWidth : "auto";
+}
+function useHorizontalCollapse({ transitionDuration, transitionTimingFunction = "ease", onTransitionEnd, onTransitionStart, expanded, keepMounted }) {
+	const collapsedStyles = {
+		width: 0,
+		overflow: "hidden",
+		...keepMounted ? {} : { display: "none" }
+	};
+	const onTransitionStartEvent = (0, react.useEffectEvent)(() => onTransitionStart?.());
+	const elementRef = (0, react.useRef)(null);
+	const [styles, setStylesRaw] = (0, react.useState)(expanded ? {} : collapsedStyles);
+	const [state, setState] = (0, react.useState)(expanded ? "entered" : "exited");
+	const setStyles = (newStyles) => {
+		(0, react_dom.flushSync)(() => setStylesRaw(newStyles));
+	};
+	const mergeStyles = (newStyles) => {
+		setStyles((oldStyles) => ({
+			...oldStyles,
+			...newStyles
+		}));
+	};
+	const getTransitionStyles = (width) => {
+		const duration = transitionDuration ?? getAutoWidthDuration(width);
+		return { transition: `width ${duration}ms ${transitionTimingFunction}, opacity ${duration}ms ${transitionTimingFunction}` };
+	};
+	require_use_did_update.useDidUpdate(() => {
+		if (transitionDuration !== 0) onTransitionStartEvent();
+		if (expanded) window.requestAnimationFrame(() => {
+			(0, react_dom.flushSync)(() => setState("entering"));
+			mergeStyles({
+				willChange: "width",
+				display: "block",
+				overflow: "hidden"
+			});
+			window.requestAnimationFrame(() => {
+				const width = getElementWidth(elementRef);
+				mergeStyles({
+					...getTransitionStyles(width),
+					width
+				});
+			});
+		});
+		else window.requestAnimationFrame(() => {
+			(0, react_dom.flushSync)(() => setState("exiting"));
+			const width = getElementWidth(elementRef);
+			mergeStyles({
+				...getTransitionStyles(width),
+				willChange: "width",
+				width
+			});
+			window.requestAnimationFrame(() => mergeStyles({
+				width: 0,
+				overflow: "hidden"
+			}));
+		});
+	}, [expanded]);
+	const handleTransitionEnd = (event) => {
+		if (event.target !== elementRef.current || event.propertyName !== "width") return;
+		if (expanded) {
+			const width = getElementWidth(elementRef);
+			if (width === styles.width) setStyles({});
+			else mergeStyles({ width });
+			setState("entered");
+			onTransitionEnd?.();
+		} else if (styles.width === 0) {
+			setStyles(collapsedStyles);
+			setState("exited");
+			onTransitionEnd?.();
+		}
+	};
+	return {
+		state,
+		getCollapseProps: (input) => ({
+			"aria-hidden": !expanded,
+			inert: !expanded,
+			ref: require_use_merged_ref.mergeRefs(elementRef, input?.ref),
+			onTransitionEnd: handleTransitionEnd,
+			style: {
+				boxSizing: "border-box",
+				...input?.style,
+				...styles
+			}
+		})
+	};
+}
+//#endregion
+exports.useHorizontalCollapse = useHorizontalCollapse;
+
+//# sourceMappingURL=use-horizontal-collapse.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-color-scheme/use-color-scheme.cjs

@@ -0,0 +1,10 @@
+"use client";
+const require_use_media_query = require("../use-media-query/use-media-query.cjs");
+//#region packages/@mantine/hooks/src/use-color-scheme/use-color-scheme.ts
+function useColorScheme(initialValue, options) {
+	return require_use_media_query.useMediaQuery("(prefers-color-scheme: dark)", initialValue === "dark", options) ? "dark" : "light";
+}
+//#endregion
+exports.useColorScheme = useColorScheme;
+
+//# sourceMappingURL=use-color-scheme.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-color-scheme/use-color-scheme.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-color-scheme.cjs","names":["useMediaQuery"],"sources":["../../src/use-color-scheme/use-color-scheme.ts"],"sourcesContent":["import { useMediaQuery, UseMediaQueryOptions } from '../use-media-query/use-media-query';\n\nexport type UseColorSchemeValue = 'dark' | 'light';\n\nexport function useColorScheme(\n  initialValue?: UseColorSchemeValue,\n  options?: UseMediaQueryOptions\n): UseColorSchemeValue {\n  return useMediaQuery('(prefers-color-scheme: dark)', initialValue === 'dark', options)\n    ? 'dark'\n    : 'light';\n}\n"],"mappings":";;;AAIA,SAAgB,eACd,cACA,SACqB;CACrB,OAAOA,wBAAAA,cAAc,gCAAgC,iBAAiB,QAAQ,OAAO,IACjF,SACA;AACN"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-counter/use-counter.cjs

@@ -0,0 +1,38 @@
+"use client";
+const require_clamp = require("../utils/clamp/clamp.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-counter/use-counter.ts
+const DEFAULT_OPTIONS = {
+	min: -Infinity,
+	max: Infinity
+};
+function useCounter(initialValue = 0, options) {
+	const { min, max, step: _step = 1 } = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	const step = Math.abs(_step);
+	const [count, setCount] = (0, react.useState)(require_clamp.clamp(initialValue, min, max));
+	return [count, {
+		increment: (0, react.useCallback)(() => setCount((current) => require_clamp.clamp(current + step, min, max)), [
+			min,
+			max,
+			step
+		]),
+		decrement: (0, react.useCallback)(() => setCount((current) => require_clamp.clamp(current - step, min, max)), [
+			min,
+			max,
+			step
+		]),
+		set: (0, react.useCallback)((value) => setCount(require_clamp.clamp(value, min, max)), [min, max]),
+		reset: (0, react.useCallback)(() => setCount(require_clamp.clamp(initialValue, min, max)), [
+			initialValue,
+			min,
+			max
+		])
+	}];
+}
+//#endregion
+exports.useCounter = useCounter;
+
+//# sourceMappingURL=use-counter.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-counter/use-counter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-counter.cjs","names":["clamp"],"sources":["../../src/use-counter/use-counter.ts"],"sourcesContent":["import { useCallback, useState } from 'react';\nimport { clamp } from '../utils';\n\nconst DEFAULT_OPTIONS = {\n  min: -Infinity,\n  max: Infinity,\n};\n\nexport interface UseCounterOptions {\n  min?: number;\n  max?: number;\n  step?: number;\n}\n\nexport interface UseCounterHandlers {\n  increment: () => void;\n  decrement: () => void;\n  set: (value: number) => void;\n  reset: () => void;\n}\n\nexport type UseCounterReturnValue = [number, UseCounterHandlers];\n\nexport function useCounter(initialValue = 0, options?: UseCounterOptions): UseCounterReturnValue {\n  const { min, max, step: _step = 1 } = { ...DEFAULT_OPTIONS, ...options };\n  const step = Math.abs(_step);\n  const [count, setCount] = useState<number>(clamp(initialValue, min, max));\n\n  const increment = useCallback(\n    () => setCount((current) => clamp(current + step, min, max)),\n    [min, max, step]\n  );\n\n  const decrement = useCallback(\n    () => setCount((current) => clamp(current - step, min, max)),\n    [min, max, step]\n  );\n\n  const set = useCallback((value: number) => setCount(clamp(value, min, max)), [min, max]);\n\n  const reset = useCallback(\n    () => setCount(clamp(initialValue, min, max)),\n    [initialValue, min, max]\n  );\n\n  return [count, { increment, decrement, set, reset }];\n}\n\nexport namespace useCounter {\n  export type Options = UseCounterOptions;\n  export type Handlers = UseCounterHandlers;\n  export type ReturnValue = UseCounterReturnValue;\n}\n"],"mappings":";;;;AAGA,MAAM,kBAAkB;CACtB,KAAK;CACL,KAAK;AACP;AAiBA,SAAgB,WAAW,eAAe,GAAG,SAAoD;CAC/F,MAAM,EAAE,KAAK,KAAK,MAAM,QAAQ,MAAM;EAAE,GAAG;EAAiB,GAAG;CAAQ;CACvE,MAAM,OAAO,KAAK,IAAI,KAAK;CAC3B,MAAM,CAAC,OAAO,aAAA,GAAA,MAAA,UAA6BA,cAAAA,MAAM,cAAc,KAAK,GAAG,CAAC;CAmBxE,OAAO,CAAC,OAAO;EAAE,YAAA,GAAA,MAAA,mBAhBT,UAAU,YAAYA,cAAAA,MAAM,UAAU,MAAM,KAAK,GAAG,CAAC,GAC3D;GAAC;GAAK;GAAK;EAAI,CAeQ;EAAG,YAAA,GAAA,MAAA,mBAXpB,UAAU,YAAYA,cAAAA,MAAM,UAAU,MAAM,KAAK,GAAG,CAAC,GAC3D;GAAC;GAAK;GAAK;EAAI,CAUmB;EAAG,MAAA,GAAA,MAAA,cAPd,UAAkB,SAASA,cAAAA,MAAM,OAAO,KAAK,GAAG,CAAC,GAAG,CAAC,KAAK,GAAG,CAO7C;EAAG,QAAA,GAAA,MAAA,mBAJpC,SAASA,cAAAA,MAAM,cAAc,KAAK,GAAG,CAAC,GAC5C;GAAC;GAAc;GAAK;EAAG,CAGuB;CAAE,CAAC;AACrD"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-debounced-callback/use-debounced-callback.cjs

@@ -0,0 +1,116 @@
+"use client";
+const require_use_callback_ref = require("../utils/use-callback-ref/use-callback-ref.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-debounced-callback/use-debounced-callback.ts
+function useDebouncedCallback(callback, options) {
+	const { delay, flushOnUnmount, leading, maxWait } = typeof options === "number" ? {
+		delay: options,
+		flushOnUnmount: false,
+		leading: false,
+		maxWait: void 0
+	} : options;
+	const handleCallback = require_use_callback_ref.useCallbackRef(callback);
+	const debounceTimerRef = (0, react.useRef)(0);
+	const maxWaitTimerRef = (0, react.useRef)(0);
+	const latestArgsRef = (0, react.useRef)(null);
+	const lastCallback = (0, react.useMemo)(() => {
+		const currentCallback = Object.assign((...args) => {
+			window.clearTimeout(debounceTimerRef.current);
+			latestArgsRef.current = args;
+			const isFirstCall = currentCallback._isFirstCall;
+			currentCallback._isFirstCall = false;
+			function clearTimeoutAndLeadingRef() {
+				window.clearTimeout(debounceTimerRef.current);
+				window.clearTimeout(maxWaitTimerRef.current);
+				debounceTimerRef.current = 0;
+				maxWaitTimerRef.current = 0;
+				currentCallback._isFirstCall = true;
+				currentCallback._hasPendingCallback = false;
+			}
+			function startMaxWaitTimer() {
+				if (maxWait !== void 0 && maxWaitTimerRef.current === 0) maxWaitTimerRef.current = window.setTimeout(() => {
+					if (debounceTimerRef.current !== 0) {
+						const latestArgs = latestArgsRef.current;
+						clearTimeoutAndLeadingRef();
+						handleCallback(...latestArgs);
+					}
+				}, maxWait);
+			}
+			if (leading && isFirstCall) {
+				handleCallback(...args);
+				const resetLeadingState = () => {
+					clearTimeoutAndLeadingRef();
+				};
+				const flush = () => {
+					if (debounceTimerRef.current !== 0) {
+						clearTimeoutAndLeadingRef();
+						handleCallback(...args);
+					}
+				};
+				const cancel = () => {
+					clearTimeoutAndLeadingRef();
+				};
+				currentCallback.flush = flush;
+				currentCallback.cancel = cancel;
+				debounceTimerRef.current = window.setTimeout(resetLeadingState, delay);
+				startMaxWaitTimer();
+				return;
+			}
+			if (leading && !isFirstCall) {
+				currentCallback._hasPendingCallback = true;
+				const flush = () => {
+					if (debounceTimerRef.current !== 0) {
+						clearTimeoutAndLeadingRef();
+						handleCallback(...args);
+					}
+				};
+				const cancel = () => {
+					clearTimeoutAndLeadingRef();
+				};
+				currentCallback.flush = flush;
+				currentCallback.cancel = cancel;
+				const resetLeadingState = () => {
+					clearTimeoutAndLeadingRef();
+				};
+				debounceTimerRef.current = window.setTimeout(resetLeadingState, delay);
+				startMaxWaitTimer();
+				return;
+			}
+			currentCallback._hasPendingCallback = true;
+			const flush = () => {
+				if (debounceTimerRef.current !== 0) {
+					clearTimeoutAndLeadingRef();
+					handleCallback(...args);
+				}
+			};
+			const cancel = () => {
+				clearTimeoutAndLeadingRef();
+			};
+			currentCallback.flush = flush;
+			currentCallback.cancel = cancel;
+			debounceTimerRef.current = window.setTimeout(flush, delay);
+			startMaxWaitTimer();
+		}, {
+			flush: () => {},
+			cancel: () => {},
+			isPending: () => currentCallback._hasPendingCallback,
+			_isFirstCall: true,
+			_hasPendingCallback: false
+		});
+		return currentCallback;
+	}, [
+		handleCallback,
+		delay,
+		leading,
+		maxWait
+	]);
+	(0, react.useEffect)(() => () => {
+		if (flushOnUnmount) lastCallback.flush();
+		else lastCallback.cancel();
+	}, [lastCallback, flushOnUnmount]);
+	return lastCallback;
+}
+//#endregion
+exports.useDebouncedCallback = useDebouncedCallback;
+
+//# sourceMappingURL=use-debounced-callback.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-debounced-state/use-debounced-state.cjs

@@ -0,0 +1,23 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-debounced-state/use-debounced-state.ts
+function useDebouncedState(defaultValue, wait, options = { leading: false }) {
+	const [value, setValue] = (0, react.useState)(defaultValue);
+	const timeoutRef = (0, react.useRef)(null);
+	const leadingRef = (0, react.useRef)(true);
+	const clearTimeout = () => window.clearTimeout(timeoutRef.current);
+	(0, react.useEffect)(() => clearTimeout, []);
+	return [value, (0, react.useCallback)((newValue) => {
+		clearTimeout();
+		if (leadingRef.current && options.leading) setValue(newValue);
+		else timeoutRef.current = window.setTimeout(() => {
+			leadingRef.current = true;
+			setValue(newValue);
+		}, wait);
+		leadingRef.current = false;
+	}, [options.leading, wait])];
+}
+//#endregion
+exports.useDebouncedState = useDebouncedState;
+
+//# sourceMappingURL=use-debounced-state.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-debounced-state/use-debounced-state.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounced-state.cjs","names":[],"sources":["../../src/use-debounced-state/use-debounced-state.ts"],"sourcesContent":["import { SetStateAction, useCallback, useEffect, useRef, useState } from 'react';\n\nexport interface UseDebouncedStateOptions {\n  leading?: boolean;\n}\n\nexport type UseDebouncedStateReturnValue<T> = [T, (newValue: SetStateAction<T>) => void];\n\nexport function useDebouncedState<T = any>(\n  defaultValue: T,\n  wait: number,\n  options: UseDebouncedStateOptions = { leading: false }\n): UseDebouncedStateReturnValue<T> {\n  const [value, setValue] = useState(defaultValue);\n  const timeoutRef = useRef<number | null>(null);\n  const leadingRef = useRef(true);\n\n  const clearTimeout = () => window.clearTimeout(timeoutRef.current!);\n  useEffect(() => clearTimeout, []);\n\n  const debouncedSetValue = useCallback(\n    (newValue: SetStateAction<T>) => {\n      clearTimeout();\n      if (leadingRef.current && options.leading) {\n        setValue(newValue);\n      } else {\n        timeoutRef.current = window.setTimeout(() => {\n          leadingRef.current = true;\n          setValue(newValue);\n        }, wait);\n      }\n      leadingRef.current = false;\n    },\n    [options.leading, wait]\n  );\n\n  return [value, debouncedSetValue] as const;\n}\n\nexport namespace useDebouncedState {\n  export type Options = UseDebouncedStateOptions;\n  export type ReturnValue<T> = UseDebouncedStateReturnValue<T>;\n}\n"],"mappings":";;;AAQA,SAAgB,kBACd,cACA,MACA,UAAoC,EAAE,SAAS,MAAM,GACpB;CACjC,MAAM,CAAC,OAAO,aAAA,GAAA,MAAA,UAAqB,YAAY;CAC/C,MAAM,cAAA,GAAA,MAAA,QAAmC,IAAI;CAC7C,MAAM,cAAA,GAAA,MAAA,QAAoB,IAAI;CAE9B,MAAM,qBAAqB,OAAO,aAAa,WAAW,OAAQ;CAClE,CAAA,GAAA,MAAA,iBAAgB,cAAc,CAAC,CAAC;CAkBhC,OAAO,CAAC,QAAA,GAAA,MAAA,cAfL,aAAgC;EAC/B,aAAa;EACb,IAAI,WAAW,WAAW,QAAQ,SAChC,SAAS,QAAQ;OAEjB,WAAW,UAAU,OAAO,iBAAiB;GAC3C,WAAW,UAAU;GACrB,SAAS,QAAQ;EACnB,GAAG,IAAI;EAET,WAAW,UAAU;CACvB,GACA,CAAC,QAAQ,SAAS,IAAI,CAGO,CAAC;AAClC"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-debounced-value/use-debounced-value.cjs

@@ -0,0 +1,58 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-debounced-value/use-debounced-value.ts
+function useDebouncedValue(value, wait, options = { leading: false }) {
+	const [_value, setValue] = (0, react.useState)(value);
+	const mountedRef = (0, react.useRef)(false);
+	const timeoutRef = (0, react.useRef)(null);
+	const cooldownRef = (0, react.useRef)(false);
+	const latestValueRef = (0, react.useRef)(value);
+	latestValueRef.current = value;
+	const cancel = (0, react.useCallback)(() => {
+		window.clearTimeout(timeoutRef.current);
+		timeoutRef.current = null;
+		cooldownRef.current = false;
+	}, []);
+	const flush = (0, react.useCallback)(() => {
+		if (timeoutRef.current) {
+			cancel();
+			cooldownRef.current = false;
+			setValue(latestValueRef.current);
+		}
+	}, []);
+	(0, react.useEffect)(() => {
+		if (mountedRef.current) if (!cooldownRef.current && options.leading) {
+			cooldownRef.current = true;
+			setValue(value);
+			timeoutRef.current = window.setTimeout(() => {
+				cooldownRef.current = false;
+			}, wait);
+		} else {
+			cancel();
+			timeoutRef.current = window.setTimeout(() => {
+				cooldownRef.current = false;
+				setValue(value);
+			}, wait);
+		}
+	}, [
+		value,
+		options.leading,
+		wait
+	]);
+	(0, react.useEffect)(() => {
+		mountedRef.current = true;
+		return cancel;
+	}, []);
+	return [
+		_value,
+		cancel,
+		{
+			cancel,
+			flush
+		}
+	];
+}
+//#endregion
+exports.useDebouncedValue = useDebouncedValue;
+
+//# sourceMappingURL=use-debounced-value.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-debounced-value/use-debounced-value.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounced-value.cjs","names":[],"sources":["../../src/use-debounced-value/use-debounced-value.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\n\nexport interface UseDebouncedValueOptions {\n  leading?: boolean;\n}\n\nexport interface UseDebouncedValueHandlers {\n  cancel: () => void;\n  flush: () => void;\n}\n\nexport type UseDebouncedValueReturnValue<T> = [T, () => void, UseDebouncedValueHandlers];\n\nexport function useDebouncedValue<T = any>(\n  value: T,\n  wait: number,\n  options: UseDebouncedValueOptions = { leading: false }\n): UseDebouncedValueReturnValue<T> {\n  const [_value, setValue] = useState(value);\n  const mountedRef = useRef(false);\n  const timeoutRef = useRef<number | null>(null);\n  const cooldownRef = useRef(false);\n\n  const latestValueRef = useRef(value);\n  latestValueRef.current = value;\n\n  const cancel = useCallback(() => {\n    window.clearTimeout(timeoutRef.current!);\n    timeoutRef.current = null;\n    cooldownRef.current = false;\n  }, []);\n\n  const flush = useCallback(() => {\n    if (timeoutRef.current) {\n      cancel();\n      cooldownRef.current = false;\n      setValue(latestValueRef.current);\n    }\n  }, []);\n\n  useEffect(() => {\n    if (mountedRef.current) {\n      if (!cooldownRef.current && options.leading) {\n        cooldownRef.current = true;\n        setValue(value);\n        timeoutRef.current = window.setTimeout(() => {\n          cooldownRef.current = false;\n        }, wait);\n      } else {\n        cancel();\n        timeoutRef.current = window.setTimeout(() => {\n          cooldownRef.current = false;\n          setValue(value);\n        }, wait);\n      }\n    }\n  }, [value, options.leading, wait]);\n\n  useEffect(() => {\n    mountedRef.current = true;\n    return cancel;\n  }, []);\n\n  return [_value, cancel, { cancel, flush }];\n}\n\nexport namespace useDebouncedValue {\n  export type Handlers = UseDebouncedValueHandlers;\n  export type Options = UseDebouncedValueOptions;\n  export type ReturnValue<T> = UseDebouncedValueReturnValue<T>;\n}\n"],"mappings":";;;AAaA,SAAgB,kBACd,OACA,MACA,UAAoC,EAAE,SAAS,MAAM,GACpB;CACjC,MAAM,CAAC,QAAQ,aAAA,GAAA,MAAA,UAAqB,KAAK;CACzC,MAAM,cAAA,GAAA,MAAA,QAAoB,KAAK;CAC/B,MAAM,cAAA,GAAA,MAAA,QAAmC,IAAI;CAC7C,MAAM,eAAA,GAAA,MAAA,QAAqB,KAAK;CAEhC,MAAM,kBAAA,GAAA,MAAA,QAAwB,KAAK;CACnC,eAAe,UAAU;CAEzB,MAAM,UAAA,GAAA,MAAA,mBAA2B;EAC/B,OAAO,aAAa,WAAW,OAAQ;EACvC,WAAW,UAAU;EACrB,YAAY,UAAU;CACxB,GAAG,CAAC,CAAC;CAEL,MAAM,SAAA,GAAA,MAAA,mBAA0B;EAC9B,IAAI,WAAW,SAAS;GACtB,OAAO;GACP,YAAY,UAAU;GACtB,SAAS,eAAe,OAAO;EACjC;CACF,GAAG,CAAC,CAAC;CAEL,CAAA,GAAA,MAAA,iBAAgB;EACd,IAAI,WAAW,SACb,IAAI,CAAC,YAAY,WAAW,QAAQ,SAAS;GAC3C,YAAY,UAAU;GACtB,SAAS,KAAK;GACd,WAAW,UAAU,OAAO,iBAAiB;IAC3C,YAAY,UAAU;GACxB,GAAG,IAAI;EACT,OAAO;GACL,OAAO;GACP,WAAW,UAAU,OAAO,iBAAiB;IAC3C,YAAY,UAAU;IACtB,SAAS,KAAK;GAChB,GAAG,IAAI;EACT;CAEJ,GAAG;EAAC;EAAO,QAAQ;EAAS;CAAI,CAAC;CAEjC,CAAA,GAAA,MAAA,iBAAgB;EACd,WAAW,UAAU;EACrB,OAAO;CACT,GAAG,CAAC,CAAC;CAEL,OAAO;EAAC;EAAQ;EAAQ;GAAE;GAAQ;EAAM;CAAC;AAC3C"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-did-update/use-did-update.cjs

@@ -0,0 +1,17 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-did-update/use-did-update.ts
+function useDidUpdate(fn, dependencies) {
+	const mounted = (0, react.useRef)(false);
+	(0, react.useEffect)(() => () => {
+		mounted.current = false;
+	}, []);
+	(0, react.useEffect)(() => {
+		if (mounted.current) return fn();
+		mounted.current = true;
+	}, dependencies);
+}
+//#endregion
+exports.useDidUpdate = useDidUpdate;
+
+//# sourceMappingURL=use-did-update.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-did-update/use-did-update.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-did-update.cjs","names":[],"sources":["../../src/use-did-update/use-did-update.ts"],"sourcesContent":["import { DependencyList, EffectCallback, useEffect, useRef } from 'react';\n\nexport function useDidUpdate(fn: EffectCallback, dependencies?: DependencyList) {\n  const mounted = useRef(false);\n\n  useEffect(\n    () => () => {\n      mounted.current = false;\n    },\n    []\n  );\n\n  useEffect(() => {\n    if (mounted.current) {\n      return fn();\n    }\n\n    mounted.current = true;\n    return undefined;\n  }, dependencies);\n}\n"],"mappings":";;;AAEA,SAAgB,aAAa,IAAoB,cAA+B;CAC9E,MAAM,WAAA,GAAA,MAAA,QAAiB,KAAK;CAE5B,CAAA,GAAA,MAAA,uBACc;EACV,QAAQ,UAAU;CACpB,GACA,CAAC,CACH;CAEA,CAAA,GAAA,MAAA,iBAAgB;EACd,IAAI,QAAQ,SACV,OAAO,GAAG;EAGZ,QAAQ,UAAU;CAEpB,GAAG,YAAY;AACjB"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-disclosure/use-disclosure.cjs

@@ -0,0 +1,40 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-disclosure/use-disclosure.ts
+function useDisclosure(initialState = false, options = {}) {
+	const [opened, setOpened] = (0, react.useState)(initialState);
+	const open = (0, react.useCallback)(() => {
+		setOpened((isOpened) => {
+			if (!isOpened) {
+				options.onOpen?.();
+				return true;
+			}
+			return isOpened;
+		});
+	}, [options.onOpen]);
+	const close = (0, react.useCallback)(() => {
+		setOpened((isOpened) => {
+			if (isOpened) {
+				options.onClose?.();
+				return false;
+			}
+			return isOpened;
+		});
+	}, [options.onClose]);
+	return [opened, {
+		open,
+		close,
+		toggle: (0, react.useCallback)(() => {
+			opened ? close() : open();
+		}, [
+			close,
+			open,
+			opened
+		]),
+		set: setOpened
+	}];
+}
+//#endregion
+exports.useDisclosure = useDisclosure;
+
+//# sourceMappingURL=use-disclosure.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-disclosure/use-disclosure.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-disclosure.cjs","names":[],"sources":["../../src/use-disclosure/use-disclosure.ts"],"sourcesContent":["import { useCallback, useState } from 'react';\n\nexport interface UseDisclosureOptions {\n  onOpen?: () => void;\n  onClose?: () => void;\n}\n\nexport interface UseDisclosureHandlers {\n  set: (value: boolean) => void;\n  open: () => void;\n  close: () => void;\n  toggle: () => void;\n}\n\nexport type UseDisclosureReturnValue = [boolean, UseDisclosureHandlers];\n\nexport function useDisclosure(\n  initialState = false,\n  options: UseDisclosureOptions = {}\n): UseDisclosureReturnValue {\n  const [opened, setOpened] = useState(initialState);\n\n  const open = useCallback(() => {\n    setOpened((isOpened) => {\n      if (!isOpened) {\n        options.onOpen?.();\n        return true;\n      }\n      return isOpened;\n    });\n  }, [options.onOpen]);\n\n  const close = useCallback(() => {\n    setOpened((isOpened) => {\n      if (isOpened) {\n        options.onClose?.();\n        return false;\n      }\n      return isOpened;\n    });\n  }, [options.onClose]);\n\n  const toggle = useCallback(() => {\n    opened ? close() : open();\n  }, [close, open, opened]);\n\n  return [opened, { open, close, toggle, set: setOpened }];\n}\n\nexport namespace useDisclosure {\n  export type Options = UseDisclosureOptions;\n  export type Handlers = UseDisclosureHandlers;\n  export type ReturnValue = UseDisclosureReturnValue;\n}\n"],"mappings":";;;AAgBA,SAAgB,cACd,eAAe,OACf,UAAgC,CAAC,GACP;CAC1B,MAAM,CAAC,QAAQ,cAAA,GAAA,MAAA,UAAsB,YAAY;CAEjD,MAAM,QAAA,GAAA,MAAA,mBAAyB;EAC7B,WAAW,aAAa;GACtB,IAAI,CAAC,UAAU;IACb,QAAQ,SAAS;IACjB,OAAO;GACT;GACA,OAAO;EACT,CAAC;CACH,GAAG,CAAC,QAAQ,MAAM,CAAC;CAEnB,MAAM,SAAA,GAAA,MAAA,mBAA0B;EAC9B,WAAW,aAAa;GACtB,IAAI,UAAU;IACZ,QAAQ,UAAU;IAClB,OAAO;GACT;GACA,OAAO;EACT,CAAC;CACH,GAAG,CAAC,QAAQ,OAAO,CAAC;CAMpB,OAAO,CAAC,QAAQ;EAAE;EAAM;EAAO,SAAA,GAAA,MAAA,mBAJE;GAC/B,SAAS,MAAM,IAAI,KAAK;EAC1B,GAAG;GAAC;GAAO;GAAM;EAAM,CAEa;EAAG,KAAK;CAAU,CAAC;AACzD"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-document-title/use-document-title.cjs

@@ -0,0 +1,12 @@
+"use client";
+const require_use_isomorphic_effect = require("../use-isomorphic-effect/use-isomorphic-effect.cjs");
+//#region packages/@mantine/hooks/src/use-document-title/use-document-title.ts
+function useDocumentTitle(title) {
+	require_use_isomorphic_effect.useIsomorphicEffect(() => {
+		if (typeof title === "string" && title.trim().length > 0) document.title = title.trim();
+	}, [title]);
+}
+//#endregion
+exports.useDocumentTitle = useDocumentTitle;
+
+//# sourceMappingURL=use-document-title.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-document-title/use-document-title.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-document-title.cjs","names":[],"sources":["../../src/use-document-title/use-document-title.ts"],"sourcesContent":["import { useIsomorphicEffect } from '../use-isomorphic-effect/use-isomorphic-effect';\n\nexport function useDocumentTitle(title: string) {\n  useIsomorphicEffect(() => {\n    if (typeof title === 'string' && title.trim().length > 0) {\n      document.title = title.trim();\n    }\n  }, [title]);\n}\n"],"mappings":";;;AAEA,SAAgB,iBAAiB,OAAe;CAC9C,8BAAA,0BAA0B;EACxB,IAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS,GACrD,SAAS,QAAQ,MAAM,KAAK;CAEhC,GAAG,CAAC,KAAK,CAAC;AACZ"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-document-visibility/use-document-visibility.cjs

@@ -0,0 +1,17 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-document-visibility/use-document-visibility.ts
+function useDocumentVisibility() {
+	const [documentVisibility, setDocumentVisibility] = (0, react.useState)("visible");
+	(0, react.useEffect)(() => {
+		setDocumentVisibility(document.visibilityState);
+		const listener = () => setDocumentVisibility(document.visibilityState);
+		document.addEventListener("visibilitychange", listener);
+		return () => document.removeEventListener("visibilitychange", listener);
+	}, []);
+	return documentVisibility;
+}
+//#endregion
+exports.useDocumentVisibility = useDocumentVisibility;
+
+//# sourceMappingURL=use-document-visibility.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-document-visibility/use-document-visibility.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-document-visibility.cjs","names":[],"sources":["../../src/use-document-visibility/use-document-visibility.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\nexport function useDocumentVisibility(): DocumentVisibilityState {\n  const [documentVisibility, setDocumentVisibility] = useState<DocumentVisibilityState>('visible');\n\n  useEffect(() => {\n    setDocumentVisibility(document.visibilityState);\n    const listener = () => setDocumentVisibility(document.visibilityState);\n    document.addEventListener('visibilitychange', listener);\n    return () => document.removeEventListener('visibilitychange', listener);\n  }, []);\n\n  return documentVisibility;\n}\n"],"mappings":";;;AAEA,SAAgB,wBAAiD;CAC/D,MAAM,CAAC,oBAAoB,0BAAA,GAAA,MAAA,UAA2D,SAAS;CAE/F,CAAA,GAAA,MAAA,iBAAgB;EACd,sBAAsB,SAAS,eAAe;EAC9C,MAAM,iBAAiB,sBAAsB,SAAS,eAAe;EACrE,SAAS,iBAAiB,oBAAoB,QAAQ;EACtD,aAAa,SAAS,oBAAoB,oBAAoB,QAAQ;CACxE,GAAG,CAAC,CAAC;CAEL,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-drag/use-drag.cjs

@@ -0,0 +1,266 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-drag/use-drag.ts
+const VELOCITY_DECAY_MS = 100;
+function sign(n) {
+	if (n > 0) return 1;
+	if (n < 0) return -1;
+	return 0;
+}
+function getThresholdVector(threshold) {
+	const t = threshold ?? 0;
+	if (typeof t === "number") return [t, t];
+	return t;
+}
+function createInitialState() {
+	return {
+		isActive: false,
+		pointerId: -1,
+		startXY: [0, 0],
+		prevXY: [0, 0],
+		startTimestamp: 0,
+		prevTimestamp: 0,
+		thresholdMet: false,
+		firstFired: false,
+		lockedAxis: null,
+		canceled: false,
+		lastVelocity: [0, 0]
+	};
+}
+function useDrag(handler, options = {}) {
+	const [active, setActive] = (0, react.useState)(false);
+	const handlerRef = (0, react.useRef)(handler);
+	handlerRef.current = handler;
+	const optionsRef = (0, react.useRef)(options);
+	optionsRef.current = options;
+	const stateRef = (0, react.useRef)(createInitialState());
+	const documentControllerRef = (0, react.useRef)(null);
+	return {
+		ref: (0, react.useCallback)((node) => {
+			if (!node) return;
+			const elementController = new AbortController();
+			const applyAxisConstraint = (v) => {
+				const opts = optionsRef.current;
+				const s = stateRef.current;
+				if (opts.axis === "x") return [v[0], 0];
+				if (opts.axis === "y") return [0, v[1]];
+				if (opts.axis === "lock") {
+					if (s.lockedAxis === null) {
+						const t = opts.axisThreshold ?? 1;
+						if (Math.abs(v[0]) > t || Math.abs(v[1]) > t) s.lockedAxis = Math.abs(v[0]) >= Math.abs(v[1]) ? "x" : "y";
+					}
+					if (s.lockedAxis === "x") return [v[0], 0];
+					if (s.lockedAxis === "y") return [0, v[1]];
+				}
+				return v;
+			};
+			const resetDrag = () => {
+				const s = stateRef.current;
+				s.isActive = false;
+				s.pointerId = -1;
+				s.thresholdMet = false;
+				s.firstFired = false;
+				s.lockedAxis = null;
+				s.canceled = false;
+				setActive(false);
+				document.body.style.userSelect = "";
+				document.body.style.webkitUserSelect = "";
+				documentControllerRef.current?.abort();
+				documentControllerRef.current = null;
+			};
+			const cancel = () => {
+				if (stateRef.current.isActive) {
+					stateRef.current.canceled = true;
+					resetDrag();
+				}
+			};
+			const activateDrag = () => {
+				setActive(true);
+				document.body.style.userSelect = "none";
+				document.body.style.webkitUserSelect = "none";
+			};
+			const onPointerDown = (event) => {
+				if (optionsRef.current.enabled === false) return;
+				if (event.button !== 0) return;
+				if (stateRef.current.isActive) return;
+				const s = stateRef.current;
+				s.isActive = true;
+				s.pointerId = event.pointerId;
+				s.startXY = [event.clientX, event.clientY];
+				s.prevXY = [event.clientX, event.clientY];
+				s.startTimestamp = event.timeStamp;
+				s.prevTimestamp = event.timeStamp;
+				s.thresholdMet = false;
+				s.firstFired = false;
+				s.lockedAxis = null;
+				s.canceled = false;
+				s.lastVelocity = [0, 0];
+				const [tx, ty] = getThresholdVector(optionsRef.current.threshold);
+				if (tx === 0 && ty === 0) {
+					s.thresholdMet = true;
+					s.firstFired = true;
+					activateDrag();
+					handlerRef.current({
+						xy: [event.clientX, event.clientY],
+						initial: [event.clientX, event.clientY],
+						movement: [0, 0],
+						delta: [0, 0],
+						distance: [0, 0],
+						direction: [0, 0],
+						velocity: [0, 0],
+						elapsedTime: 0,
+						first: true,
+						last: false,
+						active: true,
+						tap: false,
+						canceled: false,
+						cancel,
+						event
+					});
+				}
+				documentControllerRef.current?.abort();
+				documentControllerRef.current = new AbortController();
+				const sig = documentControllerRef.current.signal;
+				document.addEventListener("pointermove", onPointerMove, { signal: sig });
+				document.addEventListener("pointerup", onPointerUp, { signal: sig });
+				document.addEventListener("pointercancel", onPointerCancel, { signal: sig });
+			};
+			const onPointerMove = (event) => {
+				const s = stateRef.current;
+				if (!s.isActive || event.pointerId !== s.pointerId) return;
+				const rawMovement = [event.clientX - s.startXY[0], event.clientY - s.startXY[1]];
+				if (!s.thresholdMet) {
+					const [tx, ty] = getThresholdVector(optionsRef.current.threshold);
+					if (Math.abs(rawMovement[0]) < tx && Math.abs(rawMovement[1]) < ty) {
+						s.prevXY = [event.clientX, event.clientY];
+						s.prevTimestamp = event.timeStamp;
+						return;
+					}
+					s.thresholdMet = true;
+					activateDrag();
+				}
+				const movement = applyAxisConstraint(rawMovement);
+				const delta = applyAxisConstraint([event.clientX - s.prevXY[0], event.clientY - s.prevXY[1]]);
+				const timeDelta = event.timeStamp - s.prevTimestamp;
+				const velocity = timeDelta > 0 ? [Math.abs(delta[0]) / timeDelta, Math.abs(delta[1]) / timeDelta] : s.lastVelocity;
+				s.lastVelocity = velocity;
+				const isFirst = !s.firstFired;
+				s.firstFired = true;
+				s.prevXY = [event.clientX, event.clientY];
+				s.prevTimestamp = event.timeStamp;
+				handlerRef.current({
+					xy: [event.clientX, event.clientY],
+					initial: [...s.startXY],
+					movement,
+					delta,
+					distance: [Math.abs(movement[0]), Math.abs(movement[1])],
+					direction: [sign(delta[0]), sign(delta[1])],
+					velocity,
+					elapsedTime: event.timeStamp - s.startTimestamp,
+					first: isFirst,
+					last: false,
+					active: true,
+					tap: false,
+					canceled: false,
+					cancel,
+					event
+				});
+			};
+			const onPointerUp = (event) => {
+				const s = stateRef.current;
+				if (!s.isActive || event.pointerId !== s.pointerId) return;
+				const opts = optionsRef.current;
+				if (!s.thresholdMet) {
+					if (opts.filterTaps) {
+						const mov = applyAxisConstraint([event.clientX - s.startXY[0], event.clientY - s.startXY[1]]);
+						const dist = [Math.abs(mov[0]), Math.abs(mov[1])];
+						const isTap = Math.max(dist[0], dist[1]) < (opts.tapThreshold ?? 3);
+						handlerRef.current({
+							xy: [event.clientX, event.clientY],
+							initial: [...s.startXY],
+							movement: mov,
+							delta: mov,
+							distance: dist,
+							direction: [sign(mov[0]), sign(mov[1])],
+							velocity: [0, 0],
+							elapsedTime: event.timeStamp - s.startTimestamp,
+							first: true,
+							last: true,
+							active: false,
+							tap: isTap,
+							canceled: false,
+							cancel,
+							event
+						});
+					}
+					resetDrag();
+					return;
+				}
+				const movement = applyAxisConstraint([event.clientX - s.startXY[0], event.clientY - s.startXY[1]]);
+				const distance = [Math.abs(movement[0]), Math.abs(movement[1])];
+				const delta = applyAxisConstraint([event.clientX - s.prevXY[0], event.clientY - s.prevXY[1]]);
+				const velocity = event.timeStamp - s.prevTimestamp > VELOCITY_DECAY_MS ? [0, 0] : s.lastVelocity;
+				const maxDistance = Math.max(distance[0], distance[1]);
+				const tap = opts.filterTaps === true && maxDistance < (opts.tapThreshold ?? 3);
+				handlerRef.current({
+					xy: [event.clientX, event.clientY],
+					initial: [...s.startXY],
+					movement,
+					delta,
+					distance,
+					direction: [sign(delta[0]), sign(delta[1])],
+					velocity,
+					elapsedTime: event.timeStamp - s.startTimestamp,
+					first: !s.firstFired,
+					last: true,
+					active: false,
+					tap,
+					canceled: false,
+					cancel,
+					event
+				});
+				resetDrag();
+			};
+			const onPointerCancel = (event) => {
+				const s = stateRef.current;
+				if (!s.isActive || event.pointerId !== s.pointerId) return;
+				const movement = applyAxisConstraint([event.clientX - s.startXY[0], event.clientY - s.startXY[1]]);
+				handlerRef.current({
+					xy: [event.clientX, event.clientY],
+					initial: [...s.startXY],
+					movement,
+					delta: [0, 0],
+					distance: [Math.abs(movement[0]), Math.abs(movement[1])],
+					direction: [0, 0],
+					velocity: [0, 0],
+					elapsedTime: event.timeStamp - s.startTimestamp,
+					first: !s.firstFired,
+					last: true,
+					active: false,
+					tap: false,
+					canceled: true,
+					cancel,
+					event
+				});
+				resetDrag();
+			};
+			node.addEventListener("pointerdown", onPointerDown, { signal: elementController.signal });
+			return () => {
+				elementController.abort();
+				documentControllerRef.current?.abort();
+				documentControllerRef.current = null;
+				if (stateRef.current.isActive) {
+					stateRef.current.isActive = false;
+					setActive(false);
+					document.body.style.userSelect = "";
+					document.body.style.webkitUserSelect = "";
+				}
+			};
+		}, []),
+		active
+	};
+}
+//#endregion
+exports.useDrag = useDrag;
+
+//# sourceMappingURL=use-drag.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-event-listener/use-event-listener.cjs

@@ -0,0 +1,26 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-event-listener/use-event-listener.ts
+function useEventListener(type, listener, options) {
+	const previousListener = (0, react.useRef)(null);
+	const previousNode = (0, react.useRef)(null);
+	const callbackRef = (0, react.useCallback)((node) => {
+		if (!node) return;
+		if (previousNode.current && previousListener.current) previousNode.current.removeEventListener(type, previousListener.current, options);
+		node.addEventListener(type, listener, options);
+		previousNode.current = node;
+		previousListener.current = listener;
+	}, [
+		type,
+		listener,
+		options
+	]);
+	(0, react.useEffect)(() => () => {
+		if (previousNode.current && previousListener.current) previousNode.current.removeEventListener(type, previousListener.current, options);
+	}, [type, options]);
+	return callbackRef;
+}
+//#endregion
+exports.useEventListener = useEventListener;
+
+//# sourceMappingURL=use-event-listener.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-event-listener/use-event-listener.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-event-listener.cjs","names":[],"sources":["../../src/use-event-listener/use-event-listener.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\n\nexport function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = any>(\n  type: K,\n  listener: (this: T, ev: HTMLElementEventMap[K]) => any,\n  options?: boolean | AddEventListenerOptions\n): React.RefCallback<T | null> {\n  const previousListener = useRef<Function | null>(null);\n  const previousNode = useRef<T | null>(null);\n\n  const callbackRef: React.RefCallback<T | null> = useCallback(\n    (node) => {\n      if (!node) {\n        return;\n      }\n\n      if (previousNode.current && previousListener.current) {\n        previousNode.current.removeEventListener(type, previousListener.current as any, options);\n      }\n\n      node.addEventListener(type, listener as any, options);\n      previousNode.current = node;\n      previousListener.current = listener;\n    },\n    [type, listener, options]\n  );\n\n  useEffect(\n    () => () => {\n      if (previousNode.current && previousListener.current) {\n        previousNode.current.removeEventListener(type, previousListener.current as any, options);\n      }\n    },\n    [type, options]\n  );\n\n  return callbackRef;\n}\n"],"mappings":";;;AAEA,SAAgB,iBACd,MACA,UACA,SAC6B;CAC7B,MAAM,oBAAA,GAAA,MAAA,QAA2C,IAAI;CACrD,MAAM,gBAAA,GAAA,MAAA,QAAgC,IAAI;CAE1C,MAAM,eAAA,GAAA,MAAA,cACH,SAAS;EACR,IAAI,CAAC,MACH;EAGF,IAAI,aAAa,WAAW,iBAAiB,SAC3C,aAAa,QAAQ,oBAAoB,MAAM,iBAAiB,SAAgB,OAAO;EAGzF,KAAK,iBAAiB,MAAM,UAAiB,OAAO;EACpD,aAAa,UAAU;EACvB,iBAAiB,UAAU;CAC7B,GACA;EAAC;EAAM;EAAU;CAAO,CAC1B;CAEA,CAAA,GAAA,MAAA,uBACc;EACV,IAAI,aAAa,WAAW,iBAAiB,SAC3C,aAAa,QAAQ,oBAAoB,MAAM,iBAAiB,SAAgB,OAAO;CAE3F,GACA,CAAC,MAAM,OAAO,CAChB;CAEA,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-eye-dropper/use-eye-dropper.cjs

@@ -0,0 +1,24 @@
+"use client";
+const require_use_isomorphic_effect = require("../use-isomorphic-effect/use-isomorphic-effect.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-eye-dropper/use-eye-dropper.ts
+function useEyeDropper() {
+	const [supported, setSupported] = (0, react.useState)(false);
+	require_use_isomorphic_effect.useIsomorphicEffect(() => {
+		setSupported(typeof window !== "undefined" && !isOpera() && "EyeDropper" in window);
+	}, []);
+	return {
+		supported,
+		open: (0, react.useCallback)((options = {}) => {
+			if (supported) return new window.EyeDropper().open(options);
+			return Promise.resolve(void 0);
+		}, [supported])
+	};
+}
+function isOpera() {
+	return navigator.userAgent.includes("OPR");
+}
+//#endregion
+exports.useEyeDropper = useEyeDropper;
+
+//# sourceMappingURL=use-eye-dropper.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-eye-dropper/use-eye-dropper.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-eye-dropper.cjs","names":[],"sources":["../../src/use-eye-dropper/use-eye-dropper.ts"],"sourcesContent":["import { useCallback, useState } from 'react';\nimport { useIsomorphicEffect } from '../use-isomorphic-effect/use-isomorphic-effect';\n\nexport interface EyeDropperOpenOptions {\n  signal?: AbortSignal;\n}\n\nexport interface EyeDropperOpenReturnType {\n  sRGBHex: string;\n}\n\nexport interface UseEyeDropperReturnValue {\n  supported: boolean;\n  open: (options?: EyeDropperOpenOptions) => Promise<EyeDropperOpenReturnType | undefined>;\n}\n\nexport function useEyeDropper(): UseEyeDropperReturnValue {\n  const [supported, setSupported] = useState(false);\n\n  useIsomorphicEffect(() => {\n    setSupported(typeof window !== 'undefined' && !isOpera() && 'EyeDropper' in window);\n  }, []);\n\n  const open = useCallback(\n    (options: EyeDropperOpenOptions = {}): Promise<EyeDropperOpenReturnType | undefined> => {\n      if (supported) {\n        const eyeDropper = new (window as any).EyeDropper();\n        return eyeDropper.open(options);\n      }\n\n      return Promise.resolve(undefined);\n    },\n    [supported]\n  );\n\n  return { supported, open };\n}\n\nfunction isOpera() {\n  return navigator.userAgent.includes('OPR');\n}\n"],"mappings":";;;;AAgBA,SAAgB,gBAA0C;CACxD,MAAM,CAAC,WAAW,iBAAA,GAAA,MAAA,UAAyB,KAAK;CAEhD,8BAAA,0BAA0B;EACxB,aAAa,OAAO,WAAW,eAAe,CAAC,QAAQ,KAAK,gBAAgB,MAAM;CACpF,GAAG,CAAC,CAAC;CAcL,OAAO;EAAE;EAAW,OAAA,GAAA,MAAA,cAXjB,UAAiC,CAAC,MAAqD;GACtF,IAAI,WAEF,OAAO,IADiB,OAAe,WACvB,EAAE,KAAK,OAAO;GAGhC,OAAO,QAAQ,QAAQ,KAAA,CAAS;EAClC,GACA,CAAC,SAAS,CAGW;CAAE;AAC3B;AAEA,SAAS,UAAU;CACjB,OAAO,UAAU,UAAU,SAAS,KAAK;AAC3C"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-favicon/use-favicon.cjs

@@ -0,0 +1,32 @@
+"use client";
+const require_use_isomorphic_effect = require("../use-isomorphic-effect/use-isomorphic-effect.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-favicon/use-favicon.ts
+const MIME_TYPES = {
+	ico: "image/x-icon",
+	png: "image/png",
+	svg: "image/svg+xml",
+	gif: "image/gif"
+};
+function useFavicon(url) {
+	const link = (0, react.useRef)(null);
+	require_use_isomorphic_effect.useIsomorphicEffect(() => {
+		if (!url) return;
+		if (!link.current) {
+			document.querySelectorAll("link[rel*=\"icon\"]").forEach((element) => document.head.removeChild(element));
+			const element = document.createElement("link");
+			element.rel = "shortcut icon";
+			link.current = element;
+			document.querySelector("head").appendChild(element);
+		}
+		const splittedUrl = url.split(".");
+		const mimeType = MIME_TYPES[splittedUrl[splittedUrl.length - 1].toLowerCase()];
+		if (mimeType) link.current.setAttribute("type", mimeType);
+		else link.current.removeAttribute("type");
+		link.current.setAttribute("href", url);
+	}, [url]);
+}
+//#endregion
+exports.useFavicon = useFavicon;
+
+//# sourceMappingURL=use-favicon.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-favicon/use-favicon.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-favicon.cjs","names":[],"sources":["../../src/use-favicon/use-favicon.ts"],"sourcesContent":["import { useRef } from 'react';\nimport { useIsomorphicEffect } from '../use-isomorphic-effect/use-isomorphic-effect';\n\nconst MIME_TYPES: Record<string, string> = {\n  ico: 'image/x-icon',\n  png: 'image/png',\n  svg: 'image/svg+xml',\n  gif: 'image/gif',\n};\n\nexport function useFavicon(url: string) {\n  const link = useRef<HTMLLinkElement>(null);\n\n  useIsomorphicEffect(() => {\n    if (!url) {\n      return;\n    }\n\n    if (!link.current) {\n      const existingElements = document.querySelectorAll<HTMLLinkElement>('link[rel*=\"icon\"]');\n      existingElements.forEach((element) => document.head.removeChild(element));\n\n      const element = document.createElement('link');\n      element.rel = 'shortcut icon';\n      link.current = element;\n      document.querySelector('head')!.appendChild(element);\n    }\n\n    const splittedUrl = url.split('.');\n    const extension = splittedUrl[splittedUrl.length - 1].toLowerCase();\n    const mimeType = MIME_TYPES[extension];\n\n    if (mimeType) {\n      link.current.setAttribute('type', mimeType);\n    } else {\n      link.current.removeAttribute('type');\n    }\n\n    link.current.setAttribute('href', url);\n  }, [url]);\n}\n"],"mappings":";;;;AAGA,MAAM,aAAqC;CACzC,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;AACP;AAEA,SAAgB,WAAW,KAAa;CACtC,MAAM,QAAA,GAAA,MAAA,QAA+B,IAAI;CAEzC,8BAAA,0BAA0B;EACxB,IAAI,CAAC,KACH;EAGF,IAAI,CAAC,KAAK,SAAS;GAEjB,SADkC,iBAAkC,qBACrD,EAAE,SAAS,YAAY,SAAS,KAAK,YAAY,OAAO,CAAC;GAExE,MAAM,UAAU,SAAS,cAAc,MAAM;GAC7C,QAAQ,MAAM;GACd,KAAK,UAAU;GACf,SAAS,cAAc,MAAM,EAAG,YAAY,OAAO;EACrD;EAEA,MAAM,cAAc,IAAI,MAAM,GAAG;EAEjC,MAAM,WAAW,WADC,YAAY,YAAY,SAAS,GAAG,YAClB;EAEpC,IAAI,UACF,KAAK,QAAQ,aAAa,QAAQ,QAAQ;OAE1C,KAAK,QAAQ,gBAAgB,MAAM;EAGrC,KAAK,QAAQ,aAAa,QAAQ,GAAG;CACvC,GAAG,CAAC,GAAG,CAAC;AACV"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-fetch/use-fetch.cjs

@@ -0,0 +1,49 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-fetch/use-fetch.ts
+function useFetch(url, { autoInvoke = true, ...options } = {}) {
+	const [data, setData] = (0, react.useState)(null);
+	const [loading, setLoading] = (0, react.useState)(false);
+	const [error, setError] = (0, react.useState)(null);
+	const controller = (0, react.useRef)(null);
+	const refetch = (0, react.useCallback)(() => {
+		if (controller.current) controller.current.abort();
+		controller.current = new AbortController();
+		setLoading(true);
+		return fetch(url, {
+			...options,
+			signal: controller.current.signal
+		}).then((res) => {
+			if (!res.ok) throw new Error(`Request failed with status ${res.status}`);
+			return res.json();
+		}).then((res) => {
+			setData(res);
+			setLoading(false);
+			return res;
+		}).catch((err) => {
+			setLoading(false);
+			if (err.name !== "AbortError") setError(err);
+			return err;
+		});
+	}, [url, JSON.stringify(options)]);
+	const abort = (0, react.useCallback)(() => {
+		if (controller.current) controller.current?.abort("");
+	}, []);
+	(0, react.useEffect)(() => {
+		if (autoInvoke) refetch();
+		return () => {
+			if (controller.current) controller.current.abort("");
+		};
+	}, [refetch, autoInvoke]);
+	return {
+		data,
+		loading,
+		error,
+		refetch,
+		abort
+	};
+}
+//#endregion
+exports.useFetch = useFetch;
+
+//# sourceMappingURL=use-fetch.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-fetch/use-fetch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-fetch.cjs","names":[],"sources":["../../src/use-fetch/use-fetch.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\n\nexport interface UseFetchOptions extends RequestInit {\n  autoInvoke?: boolean;\n}\n\nexport interface UseFetchReturnValue<T> {\n  data: T | null;\n  loading: boolean;\n  error: Error | null;\n  refetch: () => Promise<any>;\n  abort: () => void;\n}\n\nexport function useFetch<T>(\n  url: string,\n  { autoInvoke = true, ...options }: UseFetchOptions = {}\n): UseFetchReturnValue<T> {\n  const [data, setData] = useState<T | null>(null);\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n  const controller = useRef<AbortController | null>(null);\n\n  const refetch = useCallback(() => {\n    if (controller.current) {\n      controller.current.abort();\n    }\n\n    controller.current = new AbortController();\n\n    setLoading(true);\n\n    return fetch(url, { ...options, signal: controller.current.signal })\n      .then((res) => {\n        if (!res.ok) {\n          throw new Error(`Request failed with status ${res.status}`);\n        }\n        return res.json();\n      })\n      .then((res) => {\n        setData(res);\n        setLoading(false);\n        return res as T;\n      })\n      .catch((err) => {\n        setLoading(false);\n\n        if (err.name !== 'AbortError') {\n          setError(err);\n        }\n\n        return err;\n      });\n  }, [url, JSON.stringify(options)]);\n\n  const abort = useCallback(() => {\n    if (controller.current) {\n      controller.current?.abort('');\n    }\n  }, []);\n\n  useEffect(() => {\n    if (autoInvoke) {\n      refetch();\n    }\n\n    return () => {\n      if (controller.current) {\n        controller.current.abort('');\n      }\n    };\n  }, [refetch, autoInvoke]);\n\n  return { data, loading, error, refetch, abort };\n}\n\nexport namespace useFetch {\n  export type Options = UseFetchOptions;\n  export type ReturnValue<T> = UseFetchReturnValue<T>;\n}\n"],"mappings":";;;AAcA,SAAgB,SACd,KACA,EAAE,aAAa,MAAM,GAAG,YAA6B,CAAC,GAC9B;CACxB,MAAM,CAAC,MAAM,YAAA,GAAA,MAAA,UAA8B,IAAI;CAC/C,MAAM,CAAC,SAAS,eAAA,GAAA,MAAA,UAAuB,KAAK;CAC5C,MAAM,CAAC,OAAO,aAAA,GAAA,MAAA,UAAmC,IAAI;CACrD,MAAM,cAAA,GAAA,MAAA,QAA4C,IAAI;CAEtD,MAAM,WAAA,GAAA,MAAA,mBAA4B;EAChC,IAAI,WAAW,SACb,WAAW,QAAQ,MAAM;EAG3B,WAAW,UAAU,IAAI,gBAAgB;EAEzC,WAAW,IAAI;EAEf,OAAO,MAAM,KAAK;GAAE,GAAG;GAAS,QAAQ,WAAW,QAAQ;EAAO,CAAC,EAChE,MAAM,QAAQ;GACb,IAAI,CAAC,IAAI,IACP,MAAM,IAAI,MAAM,8BAA8B,IAAI,QAAQ;GAE5D,OAAO,IAAI,KAAK;EAClB,CAAC,EACA,MAAM,QAAQ;GACb,QAAQ,GAAG;GACX,WAAW,KAAK;GAChB,OAAO;EACT,CAAC,EACA,OAAO,QAAQ;GACd,WAAW,KAAK;GAEhB,IAAI,IAAI,SAAS,cACf,SAAS,GAAG;GAGd,OAAO;EACT,CAAC;CACL,GAAG,CAAC,KAAK,KAAK,UAAU,OAAO,CAAC,CAAC;CAEjC,MAAM,SAAA,GAAA,MAAA,mBAA0B;EAC9B,IAAI,WAAW,SACb,WAAW,SAAS,MAAM,EAAE;CAEhC,GAAG,CAAC,CAAC;CAEL,CAAA,GAAA,MAAA,iBAAgB;EACd,IAAI,YACF,QAAQ;EAGV,aAAa;GACX,IAAI,WAAW,SACb,WAAW,QAAQ,MAAM,EAAE;EAE/B;CACF,GAAG,CAAC,SAAS,UAAU,CAAC;CAExB,OAAO;EAAE;EAAM;EAAS;EAAO;EAAS;CAAM;AAChD"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-file-dialog/use-file-dialog.cjs

@@ -0,0 +1,75 @@
+"use client";
+const require_use_isomorphic_effect = require("../use-isomorphic-effect/use-isomorphic-effect.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-file-dialog/use-file-dialog.ts
+const defaultOptions = {
+	multiple: true,
+	accept: "*"
+};
+function getInitialFilesList(files) {
+	if (!files) return null;
+	if (files instanceof FileList) return files;
+	const result = new DataTransfer();
+	for (const file of files) result.items.add(file);
+	return result.files;
+}
+function createInput(options) {
+	if (typeof document === "undefined") return null;
+	const input = document.createElement("input");
+	input.type = "file";
+	if (options.accept) input.accept = options.accept;
+	if (options.multiple) input.multiple = options.multiple;
+	if (options.capture) input.capture = options.capture;
+	if (options.directory) input.webkitdirectory = options.directory;
+	input.style.display = "none";
+	return input;
+}
+function useFileDialog(input = {}) {
+	const options = {
+		...defaultOptions,
+		...input
+	};
+	const [files, setFiles] = (0, react.useState)(getInitialFilesList(options.initialFiles));
+	const inputRef = (0, react.useRef)(null);
+	const handleChange = (0, react.useCallback)((event) => {
+		const target = event.target;
+		if (target?.files) {
+			setFiles(target.files);
+			options.onChange?.(target.files);
+		}
+	}, [options.onChange]);
+	const createAndSetupInput = (0, react.useCallback)(() => {
+		inputRef.current?.remove();
+		inputRef.current = createInput(options);
+		if (inputRef.current) {
+			inputRef.current.addEventListener("change", handleChange, { once: true });
+			if (options.onCancel) inputRef.current.addEventListener("cancel", options.onCancel, { once: true });
+			document.body.appendChild(inputRef.current);
+		}
+	}, [options, handleChange]);
+	require_use_isomorphic_effect.useIsomorphicEffect(() => {
+		createAndSetupInput();
+		return () => inputRef.current?.remove();
+	}, []);
+	const reset = (0, react.useCallback)(() => {
+		setFiles(null);
+		options.onChange?.(null);
+	}, [options.onChange]);
+	return {
+		files,
+		open: (0, react.useCallback)(() => {
+			if (options.resetOnOpen) reset();
+			createAndSetupInput();
+			inputRef.current?.click();
+		}, [
+			options.resetOnOpen,
+			reset,
+			createAndSetupInput
+		]),
+		reset
+	};
+}
+//#endregion
+exports.useFileDialog = useFileDialog;
+
+//# sourceMappingURL=use-file-dialog.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-floating-window/use-floating-window.cjs

@@ -0,0 +1,260 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-floating-window/use-floating-window.ts
+function useRefValue(value) {
+	const ref = (0, react.useRef)(value);
+	ref.current = value;
+	return ref;
+}
+function useFloatingWindow(options = {}) {
+	const [element, setElement] = (0, react.useState)(null);
+	const ref = (0, react.useRef)(null);
+	const pos = (0, react.useRef)({
+		x: 0,
+		y: 0
+	});
+	const offset = (0, react.useRef)({
+		x: 0,
+		y: 0
+	});
+	const [isDragging, setIsDragging] = (0, react.useState)(false);
+	const isDraggingRef = (0, react.useRef)(false);
+	const initialized = (0, react.useRef)(false);
+	const enabledRef = useRefValue(options.enabled);
+	const setDragging = (0, react.useCallback)((value) => {
+		setIsDragging(value);
+		isDraggingRef.current = value;
+	}, []);
+	const assignRef = (0, react.useCallback)((node) => {
+		if (node) {
+			ref.current = node;
+			setElement(node);
+		} else {
+			ref.current = null;
+			setElement(null);
+		}
+	}, []);
+	(0, react.useEffect)(() => {
+		const el = ref.current;
+		if (!initialized.current && el) {
+			initialized.current = true;
+			pos.current = calculateInitialPosition(el, options);
+			el.style.left = `${pos.current.x}px`;
+			el.style.top = `${pos.current.y}px`;
+			el.style.right = "unset";
+			el.style.bottom = "unset";
+		}
+		return () => {
+			initialized.current = false;
+		};
+	}, [
+		element,
+		options.constrainOffset,
+		options.initialPosition?.top,
+		options.initialPosition?.left,
+		options.initialPosition?.right,
+		options.initialPosition?.bottom,
+		options.constrainToViewport
+	]);
+	(0, react.useEffect)(() => {
+		const el = ref.current;
+		if (!el) return;
+		const controller = new AbortController();
+		const signal = controller.signal;
+		const onStart = (e) => {
+			if (enabledRef.current === false) return;
+			const point = "touches" in e ? e.touches[0] : e;
+			if ("button" in e && e.button !== 0) return;
+			if (!getHandle(el, e.target, options)) return;
+			setDragging(true);
+			document.body.style.userSelect = "none";
+			document.body.style.webkitUserSelect = "none";
+			const rect = el.getBoundingClientRect();
+			offset.current = {
+				x: point.clientX - rect.left,
+				y: point.clientY - rect.top
+			};
+			options.onDragStart?.();
+			document.addEventListener("mousemove", onMove, { signal });
+			document.addEventListener("mouseup", onEnd, { signal });
+			document.addEventListener("touchmove", onMove, {
+				signal,
+				passive: false
+			});
+			document.addEventListener("touchend", onEnd, { signal });
+		};
+		const onMove = (e) => {
+			if (!isDraggingRef.current) return;
+			const point = "touches" in e ? e.touches[0] : e;
+			e.preventDefault();
+			let x = point.clientX - offset.current.x;
+			let y = point.clientY - offset.current.y;
+			const constrained = getConstrainedPosition(el, {
+				x,
+				y
+			}, options);
+			if (options.axis === "x") {
+				x = constrained.x;
+				y = pos.current.y;
+			} else if (options.axis === "y") {
+				x = pos.current.x;
+				y = constrained.y;
+			} else {
+				x = constrained.x;
+				y = constrained.y;
+			}
+			pos.current = {
+				x,
+				y
+			};
+			if (ref.current) {
+				ref.current.style.left = `${x}px`;
+				ref.current.style.top = `${y}px`;
+			}
+			options.onPositionChange?.({
+				x,
+				y
+			});
+		};
+		const onEnd = () => {
+			if (isDraggingRef.current) {
+				setDragging(false);
+				document.body.style.userSelect = "";
+				document.body.style.webkitUserSelect = "";
+				options.onDragEnd?.();
+			}
+		};
+		el.addEventListener("mousedown", onStart, { signal });
+		el.addEventListener("touchstart", onStart, {
+			signal,
+			passive: false
+		});
+		return () => {
+			controller.abort();
+		};
+	}, [
+		options.constrainToViewport,
+		options.constrainOffset,
+		options.dragHandleSelector,
+		options.axis,
+		options.onPositionChange,
+		options.onDragStart,
+		options.onDragEnd,
+		options.initialPosition?.top,
+		options.initialPosition?.left,
+		options.initialPosition?.right,
+		options.initialPosition?.bottom,
+		element
+	]);
+	(0, react.useEffect)(() => {
+		const el = ref.current;
+		if (!el) return;
+		const observer = new ResizeObserver(() => {
+			const constrained = getConstrainedPosition(el, pos.current, options);
+			pos.current = constrained;
+			el.style.left = `${constrained.x}px`;
+			el.style.top = `${constrained.y}px`;
+		});
+		observer.observe(el);
+		return () => {
+			observer.disconnect();
+		};
+	}, [options.constrainToViewport, options.constrainOffset]);
+	return {
+		ref: assignRef,
+		setPosition: (0, react.useCallback)((position) => {
+			const el = ref.current;
+			if (!el) return;
+			const offset = options.constrainOffset ?? 0;
+			const rect = el.getBoundingClientRect();
+			let x;
+			let y;
+			if (position.left != null) x = position.left;
+			else if (position.right != null) x = window.innerWidth - rect.width - position.right;
+			if (position.top != null) y = position.top;
+			else if (position.bottom != null) y = window.innerHeight - rect.height - position.bottom;
+			x = x ?? pos.current.x;
+			y = y ?? pos.current.y;
+			if (options.constrainToViewport) {
+				const clamped = clampToViewport(x, y, el, offset);
+				x = clamped.x;
+				y = clamped.y;
+			}
+			pos.current = {
+				x,
+				y
+			};
+			el.style.left = `${x}px`;
+			el.style.top = `${y}px`;
+			options.onPositionChange?.({
+				x,
+				y
+			});
+		}, [
+			options.constrainToViewport,
+			options.constrainOffset,
+			options.onPositionChange
+		]),
+		isDragging
+	};
+}
+function px(v) {
+	return v.endsWith("px") ? parseFloat(v) : 0;
+}
+function calculateInitialPosition(el, options) {
+	const rect = el.getBoundingClientRect();
+	const offset = options.constrainOffset ?? 0;
+	const winW = window.innerWidth;
+	const winH = window.innerHeight;
+	const style = window.getComputedStyle(el);
+	const top = options.initialPosition?.top;
+	const left = options.initialPosition?.left;
+	const right = options.initialPosition?.right;
+	const bottom = options.initialPosition?.bottom;
+	let x = offset;
+	let y = offset;
+	if (left != null) x = left;
+	else if (right != null) x = winW - rect.width - right;
+	else x = px(style.left) || winW - rect.width - px(style.right) || offset;
+	if (top != null) y = top;
+	else if (bottom != null) y = winH - rect.height - bottom;
+	else y = px(style.top) || winH - rect.height - px(style.bottom) || offset;
+	return options.constrainToViewport ? clampToViewport(x, y, el, options.constrainOffset) : {
+		x,
+		y
+	};
+}
+function getConstrainedPosition(el, pos, options) {
+	if (!options.constrainToViewport || !el) return pos;
+	const rect = el.getBoundingClientRect();
+	const offset = options.constrainOffset ?? 0;
+	const maxX = window.innerWidth - rect.width - offset;
+	const maxY = window.innerHeight - rect.height - offset;
+	return {
+		x: Math.min(Math.max(offset, pos.x), maxX),
+		y: Math.min(Math.max(offset, pos.y), maxY)
+	};
+}
+function matchesExcludeSelector(target, excludeSelector) {
+	if (!excludeSelector) return false;
+	if (!(target instanceof Element)) return false;
+	return Boolean(target.closest(excludeSelector));
+}
+function getHandle(el, target, options) {
+	if (!(target instanceof Node)) return false;
+	if (!options.dragHandleSelector) return !matchesExcludeSelector(target, options.excludeDragHandleSelector);
+	return Array.from(el.querySelectorAll(options.dragHandleSelector)).some((handle) => handle.contains(target) && !matchesExcludeSelector(target, options.excludeDragHandleSelector));
+}
+function clampToViewport(x, y, el, offset = 0) {
+	const rect = el.getBoundingClientRect();
+	const maxX = window.innerWidth - rect.width - offset;
+	const maxY = window.innerHeight - rect.height - offset;
+	return {
+		x: Math.min(Math.max(offset, x), maxX),
+		y: Math.min(Math.max(offset, y), maxY)
+	};
+}
+//#endregion
+exports.useFloatingWindow = useFloatingWindow;
+
+//# sourceMappingURL=use-floating-window.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-return/use-focus-return.cjs

@@ -0,0 +1,34 @@
+"use client";
+const require_use_did_update = require("../use-did-update/use-did-update.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-focus-return/use-focus-return.ts
+function useFocusReturn({ opened, shouldReturnFocus = true }) {
+	const lastActiveElement = (0, react.useRef)(null);
+	const returnFocus = () => {
+		if (lastActiveElement.current && "focus" in lastActiveElement.current && typeof lastActiveElement.current.focus === "function") lastActiveElement.current?.focus({ preventScroll: true });
+	};
+	require_use_did_update.useDidUpdate(() => {
+		let timeout = -1;
+		const clearFocusTimeout = (event) => {
+			if (event.key === "Tab") window.clearTimeout(timeout);
+		};
+		document.addEventListener("keydown", clearFocusTimeout);
+		if (opened) lastActiveElement.current = document.activeElement;
+		else if (shouldReturnFocus) {
+			const activeElementAtClose = document.activeElement;
+			timeout = window.setTimeout(() => {
+				const currentActiveElement = document.activeElement;
+				if (currentActiveElement === null || currentActiveElement === document.body || currentActiveElement === activeElementAtClose) returnFocus();
+			}, 10);
+		}
+		return () => {
+			window.clearTimeout(timeout);
+			document.removeEventListener("keydown", clearFocusTimeout);
+		};
+	}, [opened, shouldReturnFocus]);
+	return returnFocus;
+}
+//#endregion
+exports.useFocusReturn = useFocusReturn;
+
+//# sourceMappingURL=use-focus-return.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-return/use-focus-return.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-focus-return.cjs","names":[],"sources":["../../src/use-focus-return/use-focus-return.ts"],"sourcesContent":["import { useRef } from 'react';\nimport { useDidUpdate } from '../use-did-update/use-did-update';\n\nexport interface UseFocusReturnInput {\n  opened: boolean;\n  shouldReturnFocus?: boolean;\n}\n\nexport type UseFocusReturnReturnValue = () => void;\n\nexport function useFocusReturn({\n  opened,\n  shouldReturnFocus = true,\n}: UseFocusReturnInput): UseFocusReturnReturnValue {\n  const lastActiveElement = useRef<HTMLElement>(null);\n  const returnFocus = () => {\n    if (\n      lastActiveElement.current &&\n      'focus' in lastActiveElement.current &&\n      typeof lastActiveElement.current.focus === 'function'\n    ) {\n      lastActiveElement.current?.focus({ preventScroll: true });\n    }\n  };\n\n  useDidUpdate(() => {\n    let timeout = -1;\n\n    const clearFocusTimeout = (event: KeyboardEvent) => {\n      if (event.key === 'Tab') {\n        window.clearTimeout(timeout);\n      }\n    };\n\n    document.addEventListener('keydown', clearFocusTimeout);\n\n    if (opened) {\n      lastActiveElement.current = document.activeElement as HTMLElement;\n    } else if (shouldReturnFocus) {\n      const activeElementAtClose = document.activeElement;\n      timeout = window.setTimeout(() => {\n        const currentActiveElement = document.activeElement;\n        if (\n          currentActiveElement === null ||\n          currentActiveElement === document.body ||\n          currentActiveElement === activeElementAtClose\n        ) {\n          returnFocus();\n        }\n      }, 10);\n    }\n\n    return () => {\n      window.clearTimeout(timeout);\n      document.removeEventListener('keydown', clearFocusTimeout);\n    };\n  }, [opened, shouldReturnFocus]);\n\n  return returnFocus;\n}\n\nexport namespace useFocusReturn {\n  export type Input = UseFocusReturnInput;\n  export type ReturnValue = UseFocusReturnReturnValue;\n}\n"],"mappings":";;;;AAUA,SAAgB,eAAe,EAC7B,QACA,oBAAoB,QAC6B;CACjD,MAAM,qBAAA,GAAA,MAAA,QAAwC,IAAI;CAClD,MAAM,oBAAoB;EACxB,IACE,kBAAkB,WAClB,WAAW,kBAAkB,WAC7B,OAAO,kBAAkB,QAAQ,UAAU,YAE3C,kBAAkB,SAAS,MAAM,EAAE,eAAe,KAAK,CAAC;CAE5D;CAEA,uBAAA,mBAAmB;EACjB,IAAI,UAAU;EAEd,MAAM,qBAAqB,UAAyB;GAClD,IAAI,MAAM,QAAQ,OAChB,OAAO,aAAa,OAAO;EAE/B;EAEA,SAAS,iBAAiB,WAAW,iBAAiB;EAEtD,IAAI,QACF,kBAAkB,UAAU,SAAS;OAChC,IAAI,mBAAmB;GAC5B,MAAM,uBAAuB,SAAS;GACtC,UAAU,OAAO,iBAAiB;IAChC,MAAM,uBAAuB,SAAS;IACtC,IACE,yBAAyB,QACzB,yBAAyB,SAAS,QAClC,yBAAyB,sBAEzB,YAAY;GAEhB,GAAG,EAAE;EACP;EAEA,aAAa;GACX,OAAO,aAAa,OAAO;GAC3B,SAAS,oBAAoB,WAAW,iBAAiB;EAC3D;CACF,GAAG,CAAC,QAAQ,iBAAiB,CAAC;CAE9B,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-trap/scope-tab.cjs

@@ -0,0 +1,23 @@
+"use client";
+const require_tabbable = require("./tabbable.cjs");
+//#region packages/@mantine/hooks/src/use-focus-trap/scope-tab.ts
+function scopeTab(node, event) {
+	const tabbable = require_tabbable.findTabbableDescendants(node);
+	if (!tabbable.length) {
+		event.preventDefault();
+		return;
+	}
+	const finalTabbable = tabbable[event.shiftKey ? 0 : tabbable.length - 1];
+	const root = node.getRootNode();
+	let leavingFinalTabbable = finalTabbable === root.activeElement || node === root.activeElement;
+	const activeElement = root.activeElement;
+	if (activeElement.tagName === "INPUT" && activeElement.getAttribute("type") === "radio") leavingFinalTabbable = tabbable.filter((element) => element.getAttribute("type") === "radio" && element.getAttribute("name") === activeElement.getAttribute("name")).includes(finalTabbable);
+	if (!leavingFinalTabbable) return;
+	event.preventDefault();
+	const target = tabbable[event.shiftKey ? tabbable.length - 1 : 0];
+	if (target) target.focus();
+}
+//#endregion
+exports.scopeTab = scopeTab;
+
+//# sourceMappingURL=scope-tab.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-trap/scope-tab.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-tab.cjs","names":["findTabbableDescendants"],"sources":["../../src/use-focus-trap/scope-tab.ts"],"sourcesContent":["import { findTabbableDescendants } from './tabbable';\n\nexport function scopeTab(node: HTMLElement, event: KeyboardEvent) {\n  const tabbable = findTabbableDescendants(node);\n  if (!tabbable.length) {\n    event.preventDefault();\n    return;\n  }\n  const finalTabbable = tabbable[event.shiftKey ? 0 : tabbable.length - 1];\n  const root = node.getRootNode() as unknown as DocumentOrShadowRoot;\n  let leavingFinalTabbable = finalTabbable === root.activeElement || node === root.activeElement;\n\n  const activeElement = root.activeElement as Element;\n  const activeElementIsRadio =\n    activeElement.tagName === 'INPUT' && activeElement.getAttribute('type') === 'radio';\n  if (activeElementIsRadio) {\n    const activeRadioGroup = tabbable.filter(\n      (element) =>\n        element.getAttribute('type') === 'radio' &&\n        element.getAttribute('name') === activeElement.getAttribute('name')\n    );\n    leavingFinalTabbable = activeRadioGroup.includes(finalTabbable);\n  }\n\n  if (!leavingFinalTabbable) {\n    return;\n  }\n\n  event.preventDefault();\n\n  const target = tabbable[event.shiftKey ? tabbable.length - 1 : 0];\n\n  if (target) {\n    target.focus();\n  }\n}\n"],"mappings":";;;AAEA,SAAgB,SAAS,MAAmB,OAAsB;CAChE,MAAM,WAAWA,iBAAAA,wBAAwB,IAAI;CAC7C,IAAI,CAAC,SAAS,QAAQ;EACpB,MAAM,eAAe;EACrB;CACF;CACA,MAAM,gBAAgB,SAAS,MAAM,WAAW,IAAI,SAAS,SAAS;CACtE,MAAM,OAAO,KAAK,YAAY;CAC9B,IAAI,uBAAuB,kBAAkB,KAAK,iBAAiB,SAAS,KAAK;CAEjF,MAAM,gBAAgB,KAAK;CAG3B,IADE,cAAc,YAAY,WAAW,cAAc,aAAa,MAAM,MAAM,SAO5E,uBALyB,SAAS,QAC/B,YACC,QAAQ,aAAa,MAAM,MAAM,WACjC,QAAQ,aAAa,MAAM,MAAM,cAAc,aAAa,MAAM,CAEhC,EAAE,SAAS,aAAa;CAGhE,IAAI,CAAC,sBACH;CAGF,MAAM,eAAe;CAErB,MAAM,SAAS,SAAS,MAAM,WAAW,SAAS,SAAS,IAAI;CAE/D,IAAI,QACF,OAAO,MAAM;AAEjB"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-trap/tabbable.cjs

@@ -0,0 +1,42 @@
+"use client";
+//#region packages/@mantine/hooks/src/use-focus-trap/tabbable.ts
+const TABBABLE_NODES = /input|select|textarea|button|object/;
+const FOCUS_SELECTOR = "a, input, select, textarea, button, object, [tabindex]";
+function hidden(element) {
+	if (process.env.NODE_ENV === "test") return false;
+	return element.style.display === "none";
+}
+function visible(element) {
+	if (element.getAttribute("aria-hidden") || element.getAttribute("hidden") || element.getAttribute("type") === "hidden") return false;
+	let parentElement = element;
+	while (parentElement) {
+		if (parentElement === document.body || parentElement.nodeType === 11) break;
+		if (hidden(parentElement)) return false;
+		parentElement = parentElement.parentNode;
+	}
+	return true;
+}
+function getElementTabIndex(element) {
+	let tabIndex = element.getAttribute("tabindex");
+	if (tabIndex === null) tabIndex = void 0;
+	return parseInt(tabIndex, 10);
+}
+function focusable(element) {
+	const nodeName = element.nodeName.toLowerCase();
+	const isTabIndexNotNaN = !Number.isNaN(getElementTabIndex(element));
+	return (TABBABLE_NODES.test(nodeName) && !element.disabled || (element instanceof HTMLAnchorElement ? element.href || isTabIndexNotNaN : isTabIndexNotNaN)) && visible(element);
+}
+function tabbable(element) {
+	const tabIndex = getElementTabIndex(element);
+	return (Number.isNaN(tabIndex) || tabIndex >= 0) && focusable(element);
+}
+function findTabbableDescendants(element) {
+	return Array.from(element.querySelectorAll(FOCUS_SELECTOR)).filter(tabbable);
+}
+//#endregion
+exports.FOCUS_SELECTOR = FOCUS_SELECTOR;
+exports.findTabbableDescendants = findTabbableDescendants;
+exports.focusable = focusable;
+exports.tabbable = tabbable;
+
+//# sourceMappingURL=tabbable.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-trap/tabbable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabbable.cjs","names":[],"sources":["../../src/use-focus-trap/tabbable.ts"],"sourcesContent":["const TABBABLE_NODES = /input|select|textarea|button|object/;\nexport const FOCUS_SELECTOR = 'a, input, select, textarea, button, object, [tabindex]';\n\nfunction hidden(element: HTMLElement) {\n  if (process.env.NODE_ENV === 'test') {\n    return false;\n  }\n\n  return element.style.display === 'none';\n}\n\nfunction visible(element: HTMLElement) {\n  const isHidden =\n    element.getAttribute('aria-hidden') ||\n    element.getAttribute('hidden') ||\n    element.getAttribute('type') === 'hidden';\n\n  if (isHidden) {\n    return false;\n  }\n\n  let parentElement: HTMLElement = element;\n  while (parentElement) {\n    if (parentElement === document.body || parentElement.nodeType === 11) {\n      break;\n    }\n\n    if (hidden(parentElement)) {\n      return false;\n    }\n\n    parentElement = parentElement.parentNode as HTMLElement;\n  }\n\n  return true;\n}\n\nfunction getElementTabIndex(element: HTMLElement) {\n  let tabIndex: string | null | undefined = element.getAttribute('tabindex');\n  if (tabIndex === null) {\n    tabIndex = undefined;\n  }\n  return parseInt(tabIndex as string, 10);\n}\n\nexport function focusable(element: HTMLElement) {\n  const nodeName = element.nodeName.toLowerCase();\n  const isTabIndexNotNaN = !Number.isNaN(getElementTabIndex(element));\n  const res =\n    // @ts-expect-error function accepts any html element but if it is a button, it should not be disabled to trigger the condition\n    (TABBABLE_NODES.test(nodeName) && !element.disabled) ||\n    (element instanceof HTMLAnchorElement ? element.href || isTabIndexNotNaN : isTabIndexNotNaN);\n\n  return res && visible(element);\n}\n\nexport function tabbable(element: HTMLElement) {\n  const tabIndex = getElementTabIndex(element);\n  const isTabIndexNaN = Number.isNaN(tabIndex);\n  return (isTabIndexNaN || tabIndex >= 0) && focusable(element);\n}\n\nexport function findTabbableDescendants(element: HTMLElement): HTMLElement[] {\n  return Array.from(element.querySelectorAll<HTMLElement>(FOCUS_SELECTOR)).filter(tabbable);\n}\n"],"mappings":";;AAAA,MAAM,iBAAiB;AACvB,MAAa,iBAAiB;AAE9B,SAAS,OAAO,SAAsB;CACpC,IAAI,QAAQ,IAAI,aAAa,QAC3B,OAAO;CAGT,OAAO,QAAQ,MAAM,YAAY;AACnC;AAEA,SAAS,QAAQ,SAAsB;CAMrC,IAJE,QAAQ,aAAa,aAAa,KAClC,QAAQ,aAAa,QAAQ,KAC7B,QAAQ,aAAa,MAAM,MAAM,UAGjC,OAAO;CAGT,IAAI,gBAA6B;CACjC,OAAO,eAAe;EACpB,IAAI,kBAAkB,SAAS,QAAQ,cAAc,aAAa,IAChE;EAGF,IAAI,OAAO,aAAa,GACtB,OAAO;EAGT,gBAAgB,cAAc;CAChC;CAEA,OAAO;AACT;AAEA,SAAS,mBAAmB,SAAsB;CAChD,IAAI,WAAsC,QAAQ,aAAa,UAAU;CACzE,IAAI,aAAa,MACf,WAAW,KAAA;CAEb,OAAO,SAAS,UAAoB,EAAE;AACxC;AAEA,SAAgB,UAAU,SAAsB;CAC9C,MAAM,WAAW,QAAQ,SAAS,YAAY;CAC9C,MAAM,mBAAmB,CAAC,OAAO,MAAM,mBAAmB,OAAO,CAAC;CAMlE,QAHG,eAAe,KAAK,QAAQ,KAAK,CAAC,QAAQ,aAC1C,mBAAmB,oBAAoB,QAAQ,QAAQ,mBAAmB,sBAE/D,QAAQ,OAAO;AAC/B;AAEA,SAAgB,SAAS,SAAsB;CAC7C,MAAM,WAAW,mBAAmB,OAAO;CAE3C,QADsB,OAAO,MAAM,QACf,KAAK,YAAY,MAAM,UAAU,OAAO;AAC9D;AAEA,SAAgB,wBAAwB,SAAqC;CAC3E,OAAO,MAAM,KAAK,QAAQ,iBAA8B,cAAc,CAAC,EAAE,OAAO,QAAQ;AAC1F"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-trap/use-focus-trap.cjs

@@ -0,0 +1,47 @@
+"use client";
+const require_tabbable = require("./tabbable.cjs");
+const require_scope_tab = require("./scope-tab.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-focus-trap/use-focus-trap.ts
+function useFocusTrap(active = true) {
+	const ref = (0, react.useRef)(null);
+	const focusNode = (node) => {
+		let focusElement = node.querySelector("[data-autofocus]");
+		if (!focusElement) {
+			const children = Array.from(node.querySelectorAll(require_tabbable.FOCUS_SELECTOR));
+			focusElement = children.find(require_tabbable.tabbable) || children.find(require_tabbable.focusable) || null;
+			if (!focusElement && require_tabbable.focusable(node)) focusElement = node;
+		}
+		if (focusElement) focusElement.focus({ preventScroll: true });
+		else if (process.env.NODE_ENV === "development") console.warn("[@mantine/hooks/use-focus-trap] Failed to find focusable element within provided node", node);
+	};
+	const setRef = (0, react.useCallback)((node) => {
+		if (!active) return;
+		if (node === null) {
+			ref.current = null;
+			return;
+		}
+		if (ref.current === node) return;
+		setTimeout(() => {
+			if (node.getRootNode()) focusNode(node);
+			else if (process.env.NODE_ENV === "development") console.warn("[@mantine/hooks/use-focus-trap] Ref node is not part of the dom", node);
+		});
+		ref.current = node;
+	}, [active]);
+	(0, react.useEffect)(() => {
+		if (!active) return;
+		if (ref.current) setTimeout(() => {
+			if (ref.current) focusNode(ref.current);
+		});
+		const handleKeyDown = (event) => {
+			if (event.key === "Tab" && ref.current) require_scope_tab.scopeTab(ref.current, event);
+		};
+		document.addEventListener("keydown", handleKeyDown);
+		return () => document.removeEventListener("keydown", handleKeyDown);
+	}, [active]);
+	return setRef;
+}
+//#endregion
+exports.useFocusTrap = useFocusTrap;
+
+//# sourceMappingURL=use-focus-trap.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-trap/use-focus-trap.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-focus-trap.cjs","names":["FOCUS_SELECTOR","tabbable","focusable"],"sources":["../../src/use-focus-trap/use-focus-trap.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\nimport { scopeTab } from './scope-tab';\nimport { FOCUS_SELECTOR, focusable, tabbable } from './tabbable';\n\nexport function useFocusTrap(active = true): React.RefCallback<HTMLElement | null> {\n  const ref = useRef<HTMLElement>(null);\n\n  const focusNode = (node: HTMLElement) => {\n    let focusElement: HTMLElement | null = node.querySelector('[data-autofocus]');\n\n    if (!focusElement) {\n      const children = Array.from<HTMLElement>(node.querySelectorAll(FOCUS_SELECTOR));\n      focusElement = children.find(tabbable) || children.find(focusable) || null;\n      if (!focusElement && focusable(node)) {\n        focusElement = node;\n      }\n    }\n\n    if (focusElement) {\n      focusElement.focus({ preventScroll: true });\n    } else if (process.env.NODE_ENV === 'development') {\n      // oxlint-disable-next-line no-console\n      console.warn(\n        '[@mantine/hooks/use-focus-trap] Failed to find focusable element within provided node',\n        node\n      );\n    }\n  };\n\n  const setRef = useCallback(\n    (node: HTMLElement | null) => {\n      if (!active) {\n        return;\n      }\n\n      if (node === null) {\n        ref.current = null;\n        return;\n      }\n\n      if (ref.current === node) {\n        return;\n      }\n\n      // Delay processing the HTML node by a frame. This ensures focus is assigned correctly.\n      setTimeout(() => {\n        if (node.getRootNode()) {\n          focusNode(node);\n        } else if (process.env.NODE_ENV === 'development') {\n          // oxlint-disable-next-line no-console\n          console.warn('[@mantine/hooks/use-focus-trap] Ref node is not part of the dom', node);\n        }\n      });\n\n      ref.current = node;\n    },\n    [active]\n  );\n\n  useEffect(() => {\n    if (!active) {\n      return undefined;\n    }\n\n    if (ref.current) {\n      setTimeout(() => {\n        if (ref.current) {\n          focusNode(ref.current);\n        }\n      });\n    }\n\n    const handleKeyDown = (event: KeyboardEvent) => {\n      if (event.key === 'Tab' && ref.current) {\n        scopeTab(ref.current, event);\n      }\n    };\n\n    document.addEventListener('keydown', handleKeyDown);\n    return () => document.removeEventListener('keydown', handleKeyDown);\n  }, [active]);\n\n  return setRef;\n}\n"],"mappings":";;;;;AAIA,SAAgB,aAAa,SAAS,MAA6C;CACjF,MAAM,OAAA,GAAA,MAAA,QAA0B,IAAI;CAEpC,MAAM,aAAa,SAAsB;EACvC,IAAI,eAAmC,KAAK,cAAc,kBAAkB;EAE5E,IAAI,CAAC,cAAc;GACjB,MAAM,WAAW,MAAM,KAAkB,KAAK,iBAAiBA,iBAAAA,cAAc,CAAC;GAC9E,eAAe,SAAS,KAAKC,iBAAAA,QAAQ,KAAK,SAAS,KAAKC,iBAAAA,SAAS,KAAK;GACtE,IAAI,CAAC,gBAAgBA,iBAAAA,UAAU,IAAI,GACjC,eAAe;EAEnB;EAEA,IAAI,cACF,aAAa,MAAM,EAAE,eAAe,KAAK,CAAC;OACrC,IAAI,QAAQ,IAAI,aAAa,eAElC,QAAQ,KACN,yFACA,IACF;CAEJ;CAEA,MAAM,UAAA,GAAA,MAAA,cACH,SAA6B;EAC5B,IAAI,CAAC,QACH;EAGF,IAAI,SAAS,MAAM;GACjB,IAAI,UAAU;GACd;EACF;EAEA,IAAI,IAAI,YAAY,MAClB;EAIF,iBAAiB;GACf,IAAI,KAAK,YAAY,GACnB,UAAU,IAAI;QACT,IAAI,QAAQ,IAAI,aAAa,eAElC,QAAQ,KAAK,mEAAmE,IAAI;EAExF,CAAC;EAED,IAAI,UAAU;CAChB,GACA,CAAC,MAAM,CACT;CAEA,CAAA,GAAA,MAAA,iBAAgB;EACd,IAAI,CAAC,QACH;EAGF,IAAI,IAAI,SACN,iBAAiB;GACf,IAAI,IAAI,SACN,UAAU,IAAI,OAAO;EAEzB,CAAC;EAGH,MAAM,iBAAiB,UAAyB;GAC9C,IAAI,MAAM,QAAQ,SAAS,IAAI,SAC7B,kBAAA,SAAS,IAAI,SAAS,KAAK;EAE/B;EAEA,SAAS,iBAAiB,WAAW,aAAa;EAClD,aAAa,SAAS,oBAAoB,WAAW,aAAa;CACpE,GAAG,CAAC,MAAM,CAAC;CAEX,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-within/use-focus-within.cjs

@@ -0,0 +1,55 @@
+"use client";
+const require_use_callback_ref = require("../utils/use-callback-ref/use-callback-ref.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-focus-within/use-focus-within.ts
+function containsRelatedTarget(event) {
+	if (event.currentTarget instanceof HTMLElement && event.relatedTarget instanceof HTMLElement) return event.currentTarget.contains(event.relatedTarget);
+	return false;
+}
+function useFocusWithin({ onBlur, onFocus } = {}) {
+	const [focused, setFocused] = (0, react.useState)(false);
+	const focusedRef = (0, react.useRef)(false);
+	const previousNode = (0, react.useRef)(null);
+	const onFocusRef = require_use_callback_ref.useCallbackRef(onFocus);
+	const onBlurRef = require_use_callback_ref.useCallbackRef(onBlur);
+	const _setFocused = (0, react.useCallback)((value) => {
+		setFocused(value);
+		focusedRef.current = value;
+	}, []);
+	const handleFocusIn = (0, react.useCallback)((event) => {
+		if (!focusedRef.current) {
+			_setFocused(true);
+			onFocusRef(event);
+		}
+	}, []);
+	const handleFocusOut = (0, react.useCallback)((event) => {
+		if (focusedRef.current && !containsRelatedTarget(event)) {
+			_setFocused(false);
+			onBlurRef(event);
+		}
+	}, []);
+	const callbackRef = (0, react.useCallback)((node) => {
+		if (!node) return;
+		if (previousNode.current) {
+			previousNode.current.removeEventListener("focusin", handleFocusIn);
+			previousNode.current.removeEventListener("focusout", handleFocusOut);
+		}
+		node.addEventListener("focusin", handleFocusIn);
+		node.addEventListener("focusout", handleFocusOut);
+		previousNode.current = node;
+	}, [handleFocusIn, handleFocusOut]);
+	(0, react.useEffect)(() => () => {
+		if (previousNode.current) {
+			previousNode.current.removeEventListener("focusin", handleFocusIn);
+			previousNode.current.removeEventListener("focusout", handleFocusOut);
+		}
+	}, []);
+	return {
+		ref: callbackRef,
+		focused
+	};
+}
+//#endregion
+exports.useFocusWithin = useFocusWithin;
+
+//# sourceMappingURL=use-focus-within.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-focus-within/use-focus-within.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-focus-within.cjs","names":["useCallbackRef"],"sources":["../../src/use-focus-within/use-focus-within.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\nimport { useCallbackRef } from '../utils';\n\nfunction containsRelatedTarget(event: FocusEvent) {\n  if (event.currentTarget instanceof HTMLElement && event.relatedTarget instanceof HTMLElement) {\n    return event.currentTarget.contains(event.relatedTarget);\n  }\n\n  return false;\n}\n\nexport interface UseFocusWithinOptions {\n  onFocus?: (event: FocusEvent) => void;\n  onBlur?: (event: FocusEvent) => void;\n}\n\nexport interface UseFocusWithinReturnValue<T extends HTMLElement = any> {\n  ref: React.RefCallback<T | null>;\n  focused: boolean;\n}\n\nexport function useFocusWithin<T extends HTMLElement = any>({\n  onBlur,\n  onFocus,\n}: UseFocusWithinOptions = {}): UseFocusWithinReturnValue<T> {\n  const [focused, setFocused] = useState(false);\n  const focusedRef = useRef(false);\n  const previousNode = useRef<T | null>(null);\n\n  const onFocusRef = useCallbackRef(onFocus);\n  const onBlurRef = useCallbackRef(onBlur);\n\n  const _setFocused = useCallback((value: boolean) => {\n    setFocused(value);\n    focusedRef.current = value;\n  }, []);\n\n  const handleFocusIn = useCallback((event: FocusEvent) => {\n    if (!focusedRef.current) {\n      _setFocused(true);\n      onFocusRef(event);\n    }\n  }, []);\n\n  const handleFocusOut = useCallback((event: FocusEvent) => {\n    if (focusedRef.current && !containsRelatedTarget(event)) {\n      _setFocused(false);\n      onBlurRef(event);\n    }\n  }, []);\n\n  const callbackRef: React.RefCallback<T | null> = useCallback(\n    (node) => {\n      if (!node) {\n        return;\n      }\n\n      if (previousNode.current) {\n        previousNode.current.removeEventListener('focusin', handleFocusIn);\n        previousNode.current.removeEventListener('focusout', handleFocusOut);\n      }\n\n      node.addEventListener('focusin', handleFocusIn);\n      node.addEventListener('focusout', handleFocusOut);\n      previousNode.current = node;\n    },\n    [handleFocusIn, handleFocusOut]\n  );\n\n  useEffect(\n    () => () => {\n      if (previousNode.current) {\n        previousNode.current.removeEventListener('focusin', handleFocusIn);\n        previousNode.current.removeEventListener('focusout', handleFocusOut);\n      }\n    },\n    []\n  );\n\n  return { ref: callbackRef, focused };\n}\n\nexport namespace useFocusWithin {\n  export type Options = UseFocusWithinOptions;\n  export type ReturnValue<T extends HTMLElement> = UseFocusWithinReturnValue<T>;\n}\n"],"mappings":";;;;AAGA,SAAS,sBAAsB,OAAmB;CAChD,IAAI,MAAM,yBAAyB,eAAe,MAAM,yBAAyB,aAC/E,OAAO,MAAM,cAAc,SAAS,MAAM,aAAa;CAGzD,OAAO;AACT;AAYA,SAAgB,eAA4C,EAC1D,QACA,YACyB,CAAC,GAAiC;CAC3D,MAAM,CAAC,SAAS,eAAA,GAAA,MAAA,UAAuB,KAAK;CAC5C,MAAM,cAAA,GAAA,MAAA,QAAoB,KAAK;CAC/B,MAAM,gBAAA,GAAA,MAAA,QAAgC,IAAI;CAE1C,MAAM,aAAaA,yBAAAA,eAAe,OAAO;CACzC,MAAM,YAAYA,yBAAAA,eAAe,MAAM;CAEvC,MAAM,eAAA,GAAA,MAAA,cAA2B,UAAmB;EAClD,WAAW,KAAK;EAChB,WAAW,UAAU;CACvB,GAAG,CAAC,CAAC;CAEL,MAAM,iBAAA,GAAA,MAAA,cAA6B,UAAsB;EACvD,IAAI,CAAC,WAAW,SAAS;GACvB,YAAY,IAAI;GAChB,WAAW,KAAK;EAClB;CACF,GAAG,CAAC,CAAC;CAEL,MAAM,kBAAA,GAAA,MAAA,cAA8B,UAAsB;EACxD,IAAI,WAAW,WAAW,CAAC,sBAAsB,KAAK,GAAG;GACvD,YAAY,KAAK;GACjB,UAAU,KAAK;EACjB;CACF,GAAG,CAAC,CAAC;CAEL,MAAM,eAAA,GAAA,MAAA,cACH,SAAS;EACR,IAAI,CAAC,MACH;EAGF,IAAI,aAAa,SAAS;GACxB,aAAa,QAAQ,oBAAoB,WAAW,aAAa;GACjE,aAAa,QAAQ,oBAAoB,YAAY,cAAc;EACrE;EAEA,KAAK,iBAAiB,WAAW,aAAa;EAC9C,KAAK,iBAAiB,YAAY,cAAc;EAChD,aAAa,UAAU;CACzB,GACA,CAAC,eAAe,cAAc,CAChC;CAEA,CAAA,GAAA,MAAA,uBACc;EACV,IAAI,aAAa,SAAS;GACxB,aAAa,QAAQ,oBAAoB,WAAW,aAAa;GACjE,aAAa,QAAQ,oBAAoB,YAAY,cAAc;EACrE;CACF,GACA,CAAC,CACH;CAEA,OAAO;EAAE,KAAK;EAAa;CAAQ;AACrC"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-force-update/use-force-update.cjs

@@ -0,0 +1,12 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-force-update/use-force-update.ts
+const reducer = (value) => (value + 1) % 1e6;
+function useForceUpdate() {
+	const [, update] = (0, react.useReducer)(reducer, 0);
+	return update;
+}
+//#endregion
+exports.useForceUpdate = useForceUpdate;
+
+//# sourceMappingURL=use-force-update.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-force-update/use-force-update.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-update.cjs","names":[],"sources":["../../src/use-force-update/use-force-update.ts"],"sourcesContent":["import { useReducer } from 'react';\n\nconst reducer = (value: number) => (value + 1) % 1000000;\n\nexport function useForceUpdate(): () => void {\n  const [, update] = useReducer(reducer, 0);\n  return update;\n}\n"],"mappings":";;;AAEA,MAAM,WAAW,WAAmB,QAAQ,KAAK;AAEjD,SAAgB,iBAA6B;CAC3C,MAAM,GAAG,WAAA,GAAA,MAAA,YAAqB,SAAS,CAAC;CACxC,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-fullscreen/use-fullscreen.cjs

@@ -0,0 +1,98 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-fullscreen/use-fullscreen.ts
+function getFullscreenElement() {
+	const _document = window.document;
+	return _document.fullscreenElement || _document.webkitFullscreenElement || _document.mozFullScreenElement || _document.msFullscreenElement;
+}
+function exitFullscreen() {
+	const _document = window.document;
+	if (typeof _document.exitFullscreen === "function") return _document.exitFullscreen();
+	if (typeof _document.msExitFullscreen === "function") return _document.msExitFullscreen();
+	if (typeof _document.webkitExitFullscreen === "function") return _document.webkitExitFullscreen();
+	if (typeof _document.mozCancelFullScreen === "function") return _document.mozCancelFullScreen();
+	return null;
+}
+function enterFullScreen(element) {
+	const _element = element;
+	return _element.requestFullscreen?.() || _element.msRequestFullscreen?.() || _element.webkitEnterFullscreen?.() || _element.webkitRequestFullscreen?.() || _element.mozRequestFullscreen?.();
+}
+const prefixes = [
+	"",
+	"webkit",
+	"moz",
+	"ms"
+];
+function addEvents(element, events) {
+	const { onFullScreen, onError } = events;
+	prefixes.forEach((prefix) => {
+		element.addEventListener(`${prefix}fullscreenchange`, onFullScreen);
+		element.addEventListener(`${prefix}fullscreenerror`, onError);
+	});
+	return () => removeEvents(element, events);
+}
+function removeEvents(element, { onFullScreen, onError }) {
+	prefixes.forEach((prefix) => {
+		element.removeEventListener(`${prefix}fullscreenchange`, onFullScreen);
+		element.removeEventListener(`${prefix}fullscreenerror`, onError);
+	});
+}
+function useFullscreenElement() {
+	const [fullscreen, setFullscreen] = (0, react.useState)(false);
+	const refElement = (0, react.useRef)(null);
+	const prevNodeRef = (0, react.useRef)(null);
+	const handleFullscreenChange = (0, react.useCallback)(() => {
+		setFullscreen(refElement.current === getFullscreenElement());
+	}, []);
+	const handleFullscreenError = (0, react.useCallback)(() => {
+		setFullscreen(false);
+	}, []);
+	const toggle = (0, react.useCallback)(async () => {
+		if (!getFullscreenElement() && refElement.current) await enterFullScreen(refElement.current);
+		else await exitFullscreen();
+	}, []);
+	return {
+		ref: (0, react.useCallback)((node) => {
+			if (prevNodeRef.current && prevNodeRef.current !== node) removeEvents(prevNodeRef.current, {
+				onFullScreen: handleFullscreenChange,
+				onError: handleFullscreenError
+			});
+			if (node) addEvents(node, {
+				onFullScreen: handleFullscreenChange,
+				onError: handleFullscreenError
+			});
+			refElement.current = node;
+			prevNodeRef.current = node;
+		}, []),
+		toggle,
+		fullscreen
+	};
+}
+function useFullscreenDocument() {
+	const [fullscreen, setFullscreen] = (0, react.useState)(false);
+	const handleFullscreenChange = (0, react.useCallback)(() => {
+		setFullscreen(getFullscreenElement() === window.document.documentElement);
+	}, []);
+	const handleFullscreenError = (0, react.useCallback)(() => {
+		setFullscreen(false);
+	}, []);
+	const toggle = (0, react.useCallback)(async () => {
+		if (!getFullscreenElement()) await enterFullScreen(window.document.documentElement);
+		else await exitFullscreen();
+	}, []);
+	(0, react.useEffect)(() => {
+		return addEvents(window.document.documentElement, {
+			onFullScreen: handleFullscreenChange,
+			onError: handleFullscreenError
+		});
+	}, []);
+	return {
+		toggle,
+		fullscreen
+	};
+}
+//#endregion
+exports.useFullscreenDocument = useFullscreenDocument;
+exports.useFullscreenElement = useFullscreenElement;
+
+//# sourceMappingURL=use-fullscreen.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-hash/use-hash.cjs

@@ -0,0 +1,24 @@
+"use client";
+const require_use_window_event = require("../use-window-event/use-window-event.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-hash/use-hash.ts
+function useHash({ getInitialValueInEffect = true } = {}) {
+	const [hash, setHash] = (0, react.useState)(getInitialValueInEffect ? "" : window.location.hash || "");
+	const setHashHandler = (value) => {
+		const valueWithHash = value.startsWith("#") ? value : `#${value}`;
+		window.location.hash = valueWithHash;
+		setHash(valueWithHash);
+	};
+	require_use_window_event.useWindowEvent("hashchange", () => {
+		const newHash = window.location.hash;
+		if (hash !== newHash) setHash(newHash);
+	});
+	(0, react.useEffect)(() => {
+		if (getInitialValueInEffect) setHash(window.location.hash);
+	}, []);
+	return [hash, setHashHandler];
+}
+//#endregion
+exports.useHash = useHash;
+
+//# sourceMappingURL=use-hash.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-hash/use-hash.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hash.cjs","names":[],"sources":["../../src/use-hash/use-hash.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { useWindowEvent } from '../use-window-event/use-window-event';\n\nexport interface UseHashInput {\n  getInitialValueInEffect?: boolean;\n}\n\nexport type UseHashReturnValue = [string, (value: string) => void];\n\nexport function useHash({ getInitialValueInEffect = true }: UseHashInput = {}): UseHashReturnValue {\n  const [hash, setHash] = useState<string>(\n    getInitialValueInEffect ? '' : window.location.hash || ''\n  );\n\n  const setHashHandler = (value: string) => {\n    const valueWithHash = value.startsWith('#') ? value : `#${value}`;\n    window.location.hash = valueWithHash;\n    setHash(valueWithHash);\n  };\n\n  useWindowEvent('hashchange', () => {\n    const newHash = window.location.hash;\n    if (hash !== newHash) {\n      setHash(newHash);\n    }\n  });\n\n  useEffect(() => {\n    if (getInitialValueInEffect) {\n      setHash(window.location.hash);\n    }\n  }, []);\n\n  return [hash, setHashHandler];\n}\n\nexport namespace useHash {\n  export type Options = UseHashInput;\n  export type ReturnValue = UseHashReturnValue;\n}\n"],"mappings":";;;;AASA,SAAgB,QAAQ,EAAE,0BAA0B,SAAuB,CAAC,GAAuB;CACjG,MAAM,CAAC,MAAM,YAAA,GAAA,MAAA,UACX,0BAA0B,KAAK,OAAO,SAAS,QAAQ,EACzD;CAEA,MAAM,kBAAkB,UAAkB;EACxC,MAAM,gBAAgB,MAAM,WAAW,GAAG,IAAI,QAAQ,IAAI;EAC1D,OAAO,SAAS,OAAO;EACvB,QAAQ,aAAa;CACvB;CAEA,yBAAA,eAAe,oBAAoB;EACjC,MAAM,UAAU,OAAO,SAAS;EAChC,IAAI,SAAS,SACX,QAAQ,OAAO;CAEnB,CAAC;CAED,CAAA,GAAA,MAAA,iBAAgB;EACd,IAAI,yBACF,QAAQ,OAAO,SAAS,IAAI;CAEhC,GAAG,CAAC,CAAC;CAEL,OAAO,CAAC,MAAM,cAAc;AAC9B"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-headroom/use-headroom.cjs

@@ -0,0 +1,79 @@
+"use client";
+const require_use_isomorphic_effect = require("../use-isomorphic-effect/use-isomorphic-effect.cjs");
+const require_use_window_scroll = require("../use-window-scroll/use-window-scroll.cjs");
+const require_use_scroll_direction = require("../use-scroll-direction/use-scroll-direction.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-headroom/use-headroom.ts
+const isFixed = (current, fixedAt) => current <= fixedAt;
+const isPinnedOrReleased = (current, fixedAt, isCurrentlyPinnedRef, isScrollingUp, onPin, onRelease) => {
+	const isInFixedPosition = isFixed(current, fixedAt);
+	if (isInFixedPosition && !isCurrentlyPinnedRef.current) {
+		isCurrentlyPinnedRef.current = true;
+		onPin?.();
+	} else if (!isInFixedPosition && isScrollingUp && !isCurrentlyPinnedRef.current) {
+		isCurrentlyPinnedRef.current = true;
+		onPin?.();
+	} else if (!isInFixedPosition && !isScrollingUp && isCurrentlyPinnedRef.current) {
+		isCurrentlyPinnedRef.current = false;
+		onRelease?.();
+	}
+};
+function useHeadroom({ fixedAt = 0, scrollDistance = 100, onPin, onFix, onRelease } = {}) {
+	const isCurrentlyPinnedRef = (0, react.useRef)(false);
+	const isScrollingUp = require_use_scroll_direction.useScrollDirection() === "up";
+	const [{ y: scrollPosition }] = require_use_window_scroll.useWindowScroll();
+	const onPinEvent = (0, react.useEffectEvent)(() => onPin?.());
+	const onReleaseEvent = (0, react.useEffectEvent)(() => onRelease?.());
+	const onFixEvent = (0, react.useEffectEvent)(() => onFix?.());
+	require_use_isomorphic_effect.useIsomorphicEffect(() => {
+		isPinnedOrReleased(scrollPosition, fixedAt, isCurrentlyPinnedRef, isScrollingUp, onPinEvent, onReleaseEvent);
+	}, [
+		scrollPosition,
+		fixedAt,
+		isScrollingUp
+	]);
+	const wasFixedRef = (0, react.useRef)(false);
+	require_use_isomorphic_effect.useIsomorphicEffect(() => {
+		const currentlyInFixedZone = isFixed(scrollPosition, fixedAt);
+		if (currentlyInFixedZone && !wasFixedRef.current) onFixEvent();
+		wasFixedRef.current = currentlyInFixedZone;
+	}, [scrollPosition, fixedAt]);
+	const currentlyFixed = isFixed(scrollPosition, fixedAt);
+	const prevIsFixedRef = (0, react.useRef)(currentlyFixed);
+	const directionChangeScrollYRef = (0, react.useRef)(scrollPosition);
+	const progressAtDirectionChangeRef = (0, react.useRef)(currentlyFixed ? 1 : 0);
+	const prevIsScrollingUpRef = (0, react.useRef)(isScrollingUp);
+	if (prevIsFixedRef.current !== currentlyFixed) {
+		prevIsFixedRef.current = currentlyFixed;
+		if (!currentlyFixed) {
+			directionChangeScrollYRef.current = fixedAt;
+			progressAtDirectionChangeRef.current = 1;
+		} else {
+			directionChangeScrollYRef.current = scrollPosition;
+			progressAtDirectionChangeRef.current = 1;
+		}
+		prevIsScrollingUpRef.current = isScrollingUp;
+	}
+	if (!currentlyFixed && prevIsScrollingUpRef.current !== isScrollingUp) {
+		const transitionDelta = Math.abs(scrollPosition - directionChangeScrollYRef.current);
+		const transitionProgress = prevIsScrollingUpRef.current ? Math.min(progressAtDirectionChangeRef.current + transitionDelta / scrollDistance, 1) : Math.max(progressAtDirectionChangeRef.current - transitionDelta / scrollDistance, 0);
+		prevIsScrollingUpRef.current = isScrollingUp;
+		directionChangeScrollYRef.current = scrollPosition;
+		progressAtDirectionChangeRef.current = transitionProgress;
+	}
+	let scrollProgress;
+	if (currentlyFixed) scrollProgress = 1;
+	else {
+		const scrollDelta = Math.abs(scrollPosition - directionChangeScrollYRef.current);
+		if (isScrollingUp) scrollProgress = Math.min(progressAtDirectionChangeRef.current + scrollDelta / scrollDistance, 1);
+		else scrollProgress = Math.max(progressAtDirectionChangeRef.current - scrollDelta / scrollDistance, 0);
+	}
+	return {
+		pinned: scrollProgress > 0,
+		scrollProgress
+	};
+}
+//#endregion
+exports.useHeadroom = useHeadroom;
+
+//# sourceMappingURL=use-headroom.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-hotkeys/parse-hotkey.cjs

@@ -0,0 +1,87 @@
+"use client";
+//#region packages/@mantine/hooks/src/use-hotkeys/parse-hotkey.ts
+const keyNameMap = {
+	" ": "space",
+	ArrowLeft: "arrowleft",
+	ArrowRight: "arrowright",
+	ArrowUp: "arrowup",
+	ArrowDown: "arrowdown",
+	Escape: "escape",
+	Esc: "escape",
+	esc: "escape",
+	Enter: "enter",
+	Tab: "tab",
+	Backspace: "backspace",
+	Delete: "delete",
+	Insert: "insert",
+	Home: "home",
+	End: "end",
+	PageUp: "pageup",
+	PageDown: "pagedown",
+	"+": "plus",
+	"-": "minus",
+	"*": "asterisk",
+	"/": "slash"
+};
+function normalizeKey(key) {
+	const lowerKey = key.replace("Key", "").toLowerCase();
+	return keyNameMap[key] || lowerKey;
+}
+function parseHotkey(hotkey) {
+	const keys = hotkey.toLowerCase().split("+").map((part) => part.trim());
+	const modifiers = {
+		alt: keys.includes("alt"),
+		ctrl: keys.includes("ctrl"),
+		meta: keys.includes("meta"),
+		mod: keys.includes("mod"),
+		shift: keys.includes("shift")
+	};
+	const reservedKeys = [
+		"alt",
+		"ctrl",
+		"meta",
+		"shift",
+		"mod"
+	];
+	const freeKey = keys.find((key) => !reservedKeys.includes(key));
+	return {
+		...modifiers,
+		key: freeKey === "[plus]" ? "+" : freeKey
+	};
+}
+function isExactHotkey(hotkey, event, usePhysicalKeys) {
+	const { alt, ctrl, meta, mod, shift, key } = hotkey;
+	const { altKey, ctrlKey, metaKey, shiftKey, key: pressedKey, code: pressedCode } = event;
+	if (alt !== altKey) return false;
+	if (mod) {
+		if (!ctrlKey && !metaKey) return false;
+	} else {
+		if (ctrl !== ctrlKey) return false;
+		if (meta !== metaKey) return false;
+	}
+	if (shift !== shiftKey) return false;
+	if (key && (usePhysicalKeys ? normalizeKey(pressedCode) === normalizeKey(key) : normalizeKey(pressedKey ?? pressedCode) === normalizeKey(key))) return true;
+	return false;
+}
+function getHotkeyMatcher(hotkey, usePhysicalKeys) {
+	return (event) => isExactHotkey(parseHotkey(hotkey), event, usePhysicalKeys);
+}
+function getHotkeyHandler(hotkeys) {
+	return (event) => {
+		const _event = "nativeEvent" in event ? event.nativeEvent : event;
+		hotkeys.forEach(([hotkey, handler, options = {
+			preventDefault: true,
+			usePhysicalKeys: false
+		}]) => {
+			if (getHotkeyMatcher(hotkey, options.usePhysicalKeys)(_event)) {
+				if (options.preventDefault) event.preventDefault();
+				handler(_event);
+			}
+		});
+	};
+}
+//#endregion
+exports.getHotkeyHandler = getHotkeyHandler;
+exports.getHotkeyMatcher = getHotkeyMatcher;
+
+//# sourceMappingURL=parse-hotkey.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-hotkeys/parse-hotkey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-hotkey.cjs","names":[],"sources":["../../src/use-hotkeys/parse-hotkey.ts"],"sourcesContent":["export interface KeyboardModifiers {\n  alt: boolean;\n  ctrl: boolean;\n  meta: boolean;\n  mod: boolean;\n  shift: boolean;\n}\n\nexport interface Hotkey extends KeyboardModifiers {\n  key?: string;\n}\n\ntype CheckHotkeyMatch = (event: KeyboardEvent) => boolean;\n\nconst keyNameMap: Record<string, string> = {\n  ' ': 'space',\n  ArrowLeft: 'arrowleft',\n  ArrowRight: 'arrowright',\n  ArrowUp: 'arrowup',\n  ArrowDown: 'arrowdown',\n  Escape: 'escape',\n  Esc: 'escape',\n  esc: 'escape',\n  Enter: 'enter',\n  Tab: 'tab',\n  Backspace: 'backspace',\n  Delete: 'delete',\n  Insert: 'insert',\n  Home: 'home',\n  End: 'end',\n  PageUp: 'pageup',\n  PageDown: 'pagedown',\n  '+': 'plus',\n  '-': 'minus',\n  '*': 'asterisk',\n  '/': 'slash',\n};\n\nfunction normalizeKey(key: string): string {\n  const lowerKey = key.replace('Key', '').toLowerCase();\n  return keyNameMap[key] || lowerKey;\n}\n\nexport function parseHotkey(hotkey: string): Hotkey {\n  const keys = hotkey\n    .toLowerCase()\n    .split('+')\n    .map((part) => part.trim());\n\n  const modifiers: KeyboardModifiers = {\n    alt: keys.includes('alt'),\n    ctrl: keys.includes('ctrl'),\n    meta: keys.includes('meta'),\n    mod: keys.includes('mod'),\n    shift: keys.includes('shift'),\n  };\n\n  const reservedKeys = ['alt', 'ctrl', 'meta', 'shift', 'mod'];\n\n  const freeKey = keys.find((key) => !reservedKeys.includes(key));\n\n  return {\n    ...modifiers,\n    key: freeKey === '[plus]' ? '+' : freeKey,\n  };\n}\n\nfunction isExactHotkey(hotkey: Hotkey, event: KeyboardEvent, usePhysicalKeys?: boolean): boolean {\n  const { alt, ctrl, meta, mod, shift, key } = hotkey;\n  const { altKey, ctrlKey, metaKey, shiftKey, key: pressedKey, code: pressedCode } = event;\n\n  if (alt !== altKey) {\n    return false;\n  }\n\n  if (mod) {\n    if (!ctrlKey && !metaKey) {\n      return false;\n    }\n  } else {\n    if (ctrl !== ctrlKey) {\n      return false;\n    }\n    if (meta !== metaKey) {\n      return false;\n    }\n  }\n  if (shift !== shiftKey) {\n    return false;\n  }\n\n  if (\n    key &&\n    (usePhysicalKeys\n      ? normalizeKey(pressedCode) === normalizeKey(key)\n      : normalizeKey(pressedKey ?? pressedCode) === normalizeKey(key))\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\nexport function getHotkeyMatcher(hotkey: string, usePhysicalKeys?: boolean): CheckHotkeyMatch {\n  return (event) => isExactHotkey(parseHotkey(hotkey), event, usePhysicalKeys);\n}\n\nexport interface HotkeyItemOptions {\n  preventDefault?: boolean;\n  usePhysicalKeys?: boolean;\n}\n\ntype HotkeyItem = [string, (event: any) => void, HotkeyItemOptions?];\n\nexport function getHotkeyHandler(hotkeys: HotkeyItem[]) {\n  return (event: React.KeyboardEvent<HTMLElement> | KeyboardEvent) => {\n    const _event = 'nativeEvent' in event ? event.nativeEvent : event;\n    hotkeys.forEach(\n      ([hotkey, handler, options = { preventDefault: true, usePhysicalKeys: false }]) => {\n        if (getHotkeyMatcher(hotkey, options.usePhysicalKeys)(_event)) {\n          if (options.preventDefault) {\n            event.preventDefault();\n          }\n\n          handler(_event);\n        }\n      }\n    );\n  };\n}\n"],"mappings":";;AAcA,MAAM,aAAqC;CACzC,KAAK;CACL,WAAW;CACX,YAAY;CACZ,SAAS;CACT,WAAW;CACX,QAAQ;CACR,KAAK;CACL,KAAK;CACL,OAAO;CACP,KAAK;CACL,WAAW;CACX,QAAQ;CACR,QAAQ;CACR,MAAM;CACN,KAAK;CACL,QAAQ;CACR,UAAU;CACV,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;AACP;AAEA,SAAS,aAAa,KAAqB;CACzC,MAAM,WAAW,IAAI,QAAQ,OAAO,EAAE,EAAE,YAAY;CACpD,OAAO,WAAW,QAAQ;AAC5B;AAEA,SAAgB,YAAY,QAAwB;CAClD,MAAM,OAAO,OACV,YAAY,EACZ,MAAM,GAAG,EACT,KAAK,SAAS,KAAK,KAAK,CAAC;CAE5B,MAAM,YAA+B;EACnC,KAAK,KAAK,SAAS,KAAK;EACxB,MAAM,KAAK,SAAS,MAAM;EAC1B,MAAM,KAAK,SAAS,MAAM;EAC1B,KAAK,KAAK,SAAS,KAAK;EACxB,OAAO,KAAK,SAAS,OAAO;CAC9B;CAEA,MAAM,eAAe;EAAC;EAAO;EAAQ;EAAQ;EAAS;CAAK;CAE3D,MAAM,UAAU,KAAK,MAAM,QAAQ,CAAC,aAAa,SAAS,GAAG,CAAC;CAE9D,OAAO;EACL,GAAG;EACH,KAAK,YAAY,WAAW,MAAM;CACpC;AACF;AAEA,SAAS,cAAc,QAAgB,OAAsB,iBAAoC;CAC/F,MAAM,EAAE,KAAK,MAAM,MAAM,KAAK,OAAO,QAAQ;CAC7C,MAAM,EAAE,QAAQ,SAAS,SAAS,UAAU,KAAK,YAAY,MAAM,gBAAgB;CAEnF,IAAI,QAAQ,QACV,OAAO;CAGT,IAAI;MACE,CAAC,WAAW,CAAC,SACf,OAAO;CAAA,OAEJ;EACL,IAAI,SAAS,SACX,OAAO;EAET,IAAI,SAAS,SACX,OAAO;CAEX;CACA,IAAI,UAAU,UACZ,OAAO;CAGT,IACE,QACC,kBACG,aAAa,WAAW,MAAM,aAAa,GAAG,IAC9C,aAAa,cAAc,WAAW,MAAM,aAAa,GAAG,IAEhE,OAAO;CAGT,OAAO;AACT;AAEA,SAAgB,iBAAiB,QAAgB,iBAA6C;CAC5F,QAAQ,UAAU,cAAc,YAAY,MAAM,GAAG,OAAO,eAAe;AAC7E;AASA,SAAgB,iBAAiB,SAAuB;CACtD,QAAQ,UAA4D;EAClE,MAAM,SAAS,iBAAiB,QAAQ,MAAM,cAAc;EAC5D,QAAQ,SACL,CAAC,QAAQ,SAAS,UAAU;GAAE,gBAAgB;GAAM,iBAAiB;EAAM,OAAO;GACjF,IAAI,iBAAiB,QAAQ,QAAQ,eAAe,EAAE,MAAM,GAAG;IAC7D,IAAI,QAAQ,gBACV,MAAM,eAAe;IAGvB,QAAQ,MAAM;GAChB;EACF,CACF;CACF;AACF"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-hotkeys/use-hotkeys.cjs

@@ -0,0 +1,36 @@
+"use client";
+const require_parse_hotkey = require("./parse-hotkey.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-hotkeys/use-hotkeys.ts
+function shouldFireEvent(event, tagsToIgnore, triggerOnContentEditable = false) {
+	if (event.target instanceof HTMLElement) {
+		if (triggerOnContentEditable) return !tagsToIgnore.includes(event.target.tagName);
+		return !event.target.isContentEditable && !tagsToIgnore.includes(event.target.tagName);
+	}
+	return true;
+}
+function useHotkeys(hotkeys, tagsToIgnore = [
+	"INPUT",
+	"TEXTAREA",
+	"SELECT"
+], triggerOnContentEditable = false) {
+	const handleKeydown = (0, react.useEffectEvent)((event) => {
+		hotkeys.forEach(([hotkey, handler, options = {
+			preventDefault: true,
+			usePhysicalKeys: false
+		}]) => {
+			if (require_parse_hotkey.getHotkeyMatcher(hotkey, options.usePhysicalKeys)(event) && shouldFireEvent(event, tagsToIgnore, triggerOnContentEditable)) {
+				if (options.preventDefault) event.preventDefault();
+				handler(event);
+			}
+		});
+	});
+	(0, react.useEffect)(() => {
+		document.documentElement.addEventListener("keydown", handleKeydown);
+		return () => document.documentElement.removeEventListener("keydown", handleKeydown);
+	}, []);
+}
+//#endregion
+exports.useHotkeys = useHotkeys;
+
+//# sourceMappingURL=use-hotkeys.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-hotkeys/use-hotkeys.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hotkeys.cjs","names":["getHotkeyMatcher"],"sources":["../../src/use-hotkeys/use-hotkeys.ts"],"sourcesContent":["import { useEffect, useEffectEvent } from 'react';\nimport { getHotkeyHandler, getHotkeyMatcher, HotkeyItemOptions } from './parse-hotkey';\n\nexport type { HotkeyItemOptions };\nexport { getHotkeyHandler };\n\nexport type HotkeyItem = [string, (event: KeyboardEvent) => void, HotkeyItemOptions?];\n\nfunction shouldFireEvent(\n  event: KeyboardEvent,\n  tagsToIgnore: string[],\n  triggerOnContentEditable = false\n) {\n  if (event.target instanceof HTMLElement) {\n    if (triggerOnContentEditable) {\n      return !tagsToIgnore.includes(event.target.tagName);\n    }\n\n    return !event.target.isContentEditable && !tagsToIgnore.includes(event.target.tagName);\n  }\n\n  return true;\n}\n\nexport function useHotkeys(\n  hotkeys: HotkeyItem[],\n  tagsToIgnore: string[] = ['INPUT', 'TEXTAREA', 'SELECT'],\n  triggerOnContentEditable = false\n) {\n  const handleKeydown = useEffectEvent((event: KeyboardEvent) => {\n    hotkeys.forEach(\n      ([hotkey, handler, options = { preventDefault: true, usePhysicalKeys: false }]) => {\n        if (\n          getHotkeyMatcher(hotkey, options.usePhysicalKeys)(event) &&\n          shouldFireEvent(event, tagsToIgnore, triggerOnContentEditable)\n        ) {\n          if (options.preventDefault) {\n            event.preventDefault();\n          }\n\n          handler(event);\n        }\n      }\n    );\n  });\n\n  useEffect(() => {\n    document.documentElement.addEventListener('keydown', handleKeydown);\n    return () => document.documentElement.removeEventListener('keydown', handleKeydown);\n  }, []);\n}\n\nexport namespace useHotkeys {\n  export type Hotkey = HotkeyItem;\n}\n"],"mappings":";;;;AAQA,SAAS,gBACP,OACA,cACA,2BAA2B,OAC3B;CACA,IAAI,MAAM,kBAAkB,aAAa;EACvC,IAAI,0BACF,OAAO,CAAC,aAAa,SAAS,MAAM,OAAO,OAAO;EAGpD,OAAO,CAAC,MAAM,OAAO,qBAAqB,CAAC,aAAa,SAAS,MAAM,OAAO,OAAO;CACvF;CAEA,OAAO;AACT;AAEA,SAAgB,WACd,SACA,eAAyB;CAAC;CAAS;CAAY;AAAQ,GACvD,2BAA2B,OAC3B;CACA,MAAM,iBAAA,GAAA,MAAA,iBAAgC,UAAyB;EAC7D,QAAQ,SACL,CAAC,QAAQ,SAAS,UAAU;GAAE,gBAAgB;GAAM,iBAAiB;EAAM,OAAO;GACjF,IACEA,qBAAAA,iBAAiB,QAAQ,QAAQ,eAAe,EAAE,KAAK,KACvD,gBAAgB,OAAO,cAAc,wBAAwB,GAC7D;IACA,IAAI,QAAQ,gBACV,MAAM,eAAe;IAGvB,QAAQ,KAAK;GACf;EACF,CACF;CACF,CAAC;CAED,CAAA,GAAA,MAAA,iBAAgB;EACd,SAAS,gBAAgB,iBAAiB,WAAW,aAAa;EAClE,aAAa,SAAS,gBAAgB,oBAAoB,WAAW,aAAa;CACpF,GAAG,CAAC,CAAC;AACP"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-hover/use-hover.cjs

@@ -0,0 +1,35 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-hover/use-hover.ts
+function useHover() {
+	const [hovered, setHovered] = (0, react.useState)(false);
+	const previousNode = (0, react.useRef)(null);
+	const handleMouseEnter = (0, react.useCallback)(() => {
+		setHovered(true);
+	}, []);
+	const handleMouseLeave = (0, react.useCallback)(() => {
+		setHovered(false);
+	}, []);
+	return {
+		ref: (0, react.useCallback)((node) => {
+			if (previousNode.current) {
+				previousNode.current.removeEventListener("mouseenter", handleMouseEnter);
+				previousNode.current.removeEventListener("mouseleave", handleMouseLeave);
+			}
+			if (node) {
+				node.addEventListener("mouseenter", handleMouseEnter);
+				node.addEventListener("mouseleave", handleMouseLeave);
+			}
+			previousNode.current = node;
+			return () => {
+				previousNode.current = null;
+				setHovered(false);
+			};
+		}, [handleMouseEnter, handleMouseLeave]),
+		hovered
+	};
+}
+//#endregion
+exports.useHover = useHover;
+
+//# sourceMappingURL=use-hover.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-hover/use-hover.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hover.cjs","names":[],"sources":["../../src/use-hover/use-hover.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nexport interface UseHoverReturnValue<T extends HTMLElement = any> {\n  hovered: boolean;\n  ref: React.RefCallback<T | null>;\n}\n\nexport function useHover<T extends HTMLElement = any>(): UseHoverReturnValue<T> {\n  const [hovered, setHovered] = useState(false);\n  const previousNode = useRef<HTMLElement>(null);\n\n  const handleMouseEnter = useCallback(() => {\n    setHovered(true);\n  }, []);\n\n  const handleMouseLeave = useCallback(() => {\n    setHovered(false);\n  }, []);\n\n  const ref: React.RefCallback<T | null> = useCallback(\n    (node) => {\n      if (previousNode.current) {\n        previousNode.current.removeEventListener('mouseenter', handleMouseEnter);\n        previousNode.current.removeEventListener('mouseleave', handleMouseLeave);\n      }\n\n      if (node) {\n        node.addEventListener('mouseenter', handleMouseEnter);\n        node.addEventListener('mouseleave', handleMouseLeave);\n      }\n\n      previousNode.current = node;\n\n      return () => {\n        previousNode.current = null;\n        setHovered(false);\n      };\n    },\n    [handleMouseEnter, handleMouseLeave]\n  );\n\n  return { ref, hovered };\n}\n\nexport namespace useHover {\n  export type ReturnValue<T extends HTMLElement> = UseHoverReturnValue<T>;\n}\n"],"mappings":";;;AAOA,SAAgB,WAAgE;CAC9E,MAAM,CAAC,SAAS,eAAA,GAAA,MAAA,UAAuB,KAAK;CAC5C,MAAM,gBAAA,GAAA,MAAA,QAAmC,IAAI;CAE7C,MAAM,oBAAA,GAAA,MAAA,mBAAqC;EACzC,WAAW,IAAI;CACjB,GAAG,CAAC,CAAC;CAEL,MAAM,oBAAA,GAAA,MAAA,mBAAqC;EACzC,WAAW,KAAK;CAClB,GAAG,CAAC,CAAC;CAwBL,OAAO;EAAE,MAAA,GAAA,MAAA,cArBN,SAAS;GACR,IAAI,aAAa,SAAS;IACxB,aAAa,QAAQ,oBAAoB,cAAc,gBAAgB;IACvE,aAAa,QAAQ,oBAAoB,cAAc,gBAAgB;GACzE;GAEA,IAAI,MAAM;IACR,KAAK,iBAAiB,cAAc,gBAAgB;IACpD,KAAK,iBAAiB,cAAc,gBAAgB;GACtD;GAEA,aAAa,UAAU;GAEvB,aAAa;IACX,aAAa,UAAU;IACvB,WAAW,KAAK;GAClB;EACF,GACA,CAAC,kBAAkB,gBAAgB,CAG1B;EAAG;CAAQ;AACxB"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-id/use-id.cjs

@@ -0,0 +1,17 @@
+"use client";
+const require_random_id = require("../utils/random-id/random-id.cjs");
+const require_use_isomorphic_effect = require("../use-isomorphic-effect/use-isomorphic-effect.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-id/use-id.ts
+function useId(staticId) {
+	const [uuid, setUuid] = (0, react.useState)(`mantine-${(0, react.useId)().replace(/:/g, "")}`);
+	require_use_isomorphic_effect.useIsomorphicEffect(() => {
+		setUuid(require_random_id.randomId());
+	}, []);
+	if (typeof staticId === "string") return staticId;
+	return uuid;
+}
+//#endregion
+exports.useId = useId;
+
+//# sourceMappingURL=use-id.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-id/use-id.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-id.cjs","names":["randomId"],"sources":["../../src/use-id/use-id.ts"],"sourcesContent":["import { useId as useReactId, useState } from 'react';\nimport { useIsomorphicEffect } from '../use-isomorphic-effect/use-isomorphic-effect';\nimport { randomId } from '../utils';\n\nexport function useId(staticId?: string) {\n  const reactId = useReactId();\n  const [uuid, setUuid] = useState(`mantine-${reactId.replace(/:/g, '')}`);\n\n  useIsomorphicEffect(() => {\n    setUuid(randomId());\n  }, []);\n\n  if (typeof staticId === 'string') {\n    return staticId;\n  }\n\n  return uuid;\n}\n"],"mappings":";;;;;AAIA,SAAgB,MAAM,UAAmB;CAEvC,MAAM,CAAC,MAAM,YAAA,GAAA,MAAA,UAAoB,YAAA,GAAA,MAAA,OAAiB,EAAE,QAAQ,MAAM,EAAE,GAAG;CAEvE,8BAAA,0BAA0B;EACxB,QAAQA,kBAAAA,SAAS,CAAC;CACpB,GAAG,CAAC,CAAC;CAEL,IAAI,OAAO,aAAa,UACtB,OAAO;CAGT,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-idle/use-idle.cjs

@@ -0,0 +1,45 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-idle/use-idle.ts
+const DEFAULT_OPTIONS = {
+	events: [
+		"keydown",
+		"mousemove",
+		"touchmove",
+		"click",
+		"scroll",
+		"wheel"
+	],
+	initialState: true
+};
+function useIdle(timeout, options) {
+	const { events, initialState } = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	const [idle, setIdle] = (0, react.useState)(initialState);
+	const timer = (0, react.useRef)(-1);
+	(0, react.useEffect)(() => {
+		const handleEvents = () => {
+			setIdle(false);
+			if (timer.current) window.clearTimeout(timer.current);
+			timer.current = window.setTimeout(() => {
+				setIdle(true);
+			}, timeout);
+		};
+		events.forEach((event) => document.addEventListener(event, handleEvents));
+		timer.current = window.setTimeout(() => {
+			setIdle(true);
+		}, timeout);
+		return () => {
+			events.forEach((event) => document.removeEventListener(event, handleEvents));
+			window.clearTimeout(timer.current);
+			timer.current = -1;
+		};
+	}, [timeout]);
+	return idle;
+}
+//#endregion
+exports.useIdle = useIdle;
+
+//# sourceMappingURL=use-idle.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-idle/use-idle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-idle.cjs","names":[],"sources":["../../src/use-idle/use-idle.ts"],"sourcesContent":["import { useEffect, useRef, useState } from 'react';\n\nexport interface UseIdleOptions {\n  events?: (keyof DocumentEventMap)[];\n  initialState?: boolean;\n}\n\nconst DEFAULT_OPTIONS: Required<UseIdleOptions> = {\n  events: ['keydown', 'mousemove', 'touchmove', 'click', 'scroll', 'wheel'],\n  initialState: true,\n};\n\nexport function useIdle(timeout: number, options?: UseIdleOptions) {\n  const { events, initialState } = { ...DEFAULT_OPTIONS, ...options };\n  const [idle, setIdle] = useState(initialState);\n  const timer = useRef(-1);\n\n  useEffect(() => {\n    const handleEvents = () => {\n      setIdle(false);\n\n      if (timer.current) {\n        window.clearTimeout(timer.current);\n      }\n\n      timer.current = window.setTimeout(() => {\n        setIdle(true);\n      }, timeout);\n    };\n\n    events.forEach((event) => document.addEventListener(event, handleEvents));\n\n    // Start the timer immediately instead of waiting for the first event to happen\n    timer.current = window.setTimeout(() => {\n      setIdle(true);\n    }, timeout);\n\n    return () => {\n      events.forEach((event) => document.removeEventListener(event, handleEvents));\n      window.clearTimeout(timer.current);\n      timer.current = -1;\n    };\n  }, [timeout]);\n\n  return idle;\n}\n\nexport namespace useIdle {\n  export type Options = UseIdleOptions;\n}\n"],"mappings":";;;AAOA,MAAM,kBAA4C;CAChD,QAAQ;EAAC;EAAW;EAAa;EAAa;EAAS;EAAU;CAAO;CACxE,cAAc;AAChB;AAEA,SAAgB,QAAQ,SAAiB,SAA0B;CACjE,MAAM,EAAE,QAAQ,iBAAiB;EAAE,GAAG;EAAiB,GAAG;CAAQ;CAClE,MAAM,CAAC,MAAM,YAAA,GAAA,MAAA,UAAoB,YAAY;CAC7C,MAAM,SAAA,GAAA,MAAA,QAAe,EAAE;CAEvB,CAAA,GAAA,MAAA,iBAAgB;EACd,MAAM,qBAAqB;GACzB,QAAQ,KAAK;GAEb,IAAI,MAAM,SACR,OAAO,aAAa,MAAM,OAAO;GAGnC,MAAM,UAAU,OAAO,iBAAiB;IACtC,QAAQ,IAAI;GACd,GAAG,OAAO;EACZ;EAEA,OAAO,SAAS,UAAU,SAAS,iBAAiB,OAAO,YAAY,CAAC;EAGxE,MAAM,UAAU,OAAO,iBAAiB;GACtC,QAAQ,IAAI;EACd,GAAG,OAAO;EAEV,aAAa;GACX,OAAO,SAAS,UAAU,SAAS,oBAAoB,OAAO,YAAY,CAAC;GAC3E,OAAO,aAAa,MAAM,OAAO;GACjC,MAAM,UAAU;EAClB;CACF,GAAG,CAAC,OAAO,CAAC;CAEZ,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-in-viewport/use-in-viewport.cjs

@@ -0,0 +1,29 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-in-viewport/use-in-viewport.ts
+function useInViewport() {
+	const observer = (0, react.useRef)(null);
+	const [inViewport, setInViewport] = (0, react.useState)(false);
+	return {
+		ref: (0, react.useCallback)((node) => {
+			if (typeof IntersectionObserver !== "undefined") {
+				observer.current?.disconnect();
+				if (node) {
+					observer.current = new IntersectionObserver((entries) => {
+						const lastEntry = entries[entries.length - 1];
+						setInViewport(lastEntry.isIntersecting);
+					});
+					observer.current.observe(node);
+				} else {
+					observer.current = null;
+					setInViewport(false);
+				}
+			}
+		}, []),
+		inViewport
+	};
+}
+//#endregion
+exports.useInViewport = useInViewport;
+
+//# sourceMappingURL=use-in-viewport.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-in-viewport/use-in-viewport.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-in-viewport.cjs","names":[],"sources":["../../src/use-in-viewport/use-in-viewport.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nexport interface UseInViewportReturnValue<T extends HTMLElement = any> {\n  inViewport: boolean;\n  ref: React.RefCallback<T | null>;\n}\n\nexport function useInViewport<T extends HTMLElement = any>(): UseInViewportReturnValue<T> {\n  const observer = useRef<IntersectionObserver | null>(null);\n  const [inViewport, setInViewport] = useState(false);\n\n  const ref: React.RefCallback<T | null> = useCallback((node) => {\n    if (typeof IntersectionObserver !== 'undefined') {\n      observer.current?.disconnect();\n\n      if (node) {\n        observer.current = new IntersectionObserver((entries) => {\n          const lastEntry = entries[entries.length - 1];\n          setInViewport(lastEntry.isIntersecting);\n        });\n        observer.current.observe(node);\n      } else {\n        observer.current = null;\n        setInViewport(false);\n      }\n    }\n  }, []);\n\n  return { ref, inViewport };\n}\n\nexport namespace useInViewport {\n  export type ReturnValue<T extends HTMLElement> = UseInViewportReturnValue<T>;\n}\n"],"mappings":";;;AAOA,SAAgB,gBAA0E;CACxF,MAAM,YAAA,GAAA,MAAA,QAA+C,IAAI;CACzD,MAAM,CAAC,YAAY,kBAAA,GAAA,MAAA,UAA0B,KAAK;CAmBlD,OAAO;EAAE,MAAA,GAAA,MAAA,cAjB6C,SAAS;GAC7D,IAAI,OAAO,yBAAyB,aAAa;IAC/C,SAAS,SAAS,WAAW;IAE7B,IAAI,MAAM;KACR,SAAS,UAAU,IAAI,sBAAsB,YAAY;MACvD,MAAM,YAAY,QAAQ,QAAQ,SAAS;MAC3C,cAAc,UAAU,cAAc;KACxC,CAAC;KACD,SAAS,QAAQ,QAAQ,IAAI;IAC/B,OAAO;KACL,SAAS,UAAU;KACnB,cAAc,KAAK;IACrB;GACF;EACF,GAAG,CAAC,CAEO;EAAG;CAAW;AAC3B"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-input-state/use-input-state.cjs

@@ -0,0 +1,22 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-input-state/use-input-state.ts
+function getInputOnChange(setValue) {
+	return (val) => {
+		if (!val) setValue(val);
+		else if (typeof val === "function") setValue(val);
+		else if (typeof val === "object" && "nativeEvent" in val) {
+			const { currentTarget } = val;
+			if (currentTarget.type === "checkbox") setValue(currentTarget.checked);
+			else setValue(currentTarget.value);
+		} else setValue(val);
+	};
+}
+function useInputState(initialState) {
+	const [value, setValue] = (0, react.useState)(initialState);
+	return [value, getInputOnChange(setValue)];
+}
+//#endregion
+exports.useInputState = useInputState;
+
+//# sourceMappingURL=use-input-state.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-input-state/use-input-state.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-input-state.cjs","names":[],"sources":["../../src/use-input-state/use-input-state.ts"],"sourcesContent":["import { useState } from 'react';\n\nexport function getInputOnChange<T>(\n  setValue: (value: null | undefined | T | ((current: T) => T)) => void\n) {\n  return (val: null | undefined | T | React.ChangeEvent<any> | ((current: T) => T)) => {\n    if (!val) {\n      setValue(val as T);\n    } else if (typeof val === 'function') {\n      setValue(val);\n    } else if (typeof val === 'object' && 'nativeEvent' in val) {\n      const { currentTarget } = val;\n\n      if (currentTarget.type === 'checkbox') {\n        setValue((currentTarget as any).checked as any);\n      } else {\n        setValue(currentTarget.value as any);\n      }\n    } else {\n      setValue(val);\n    }\n  };\n}\n\nexport type UseInputStateReturnValue<T> = [\n  T,\n  (value: null | undefined | T | React.ChangeEvent<any>) => void,\n];\n\nexport function useInputState<T>(initialState: T): UseInputStateReturnValue<T> {\n  const [value, setValue] = useState<T>(initialState);\n  return [value, getInputOnChange<T>(setValue as any)];\n}\n\nexport namespace useInputState {\n  export type ReturnValue<T> = UseInputStateReturnValue<T>;\n}\n"],"mappings":";;;AAEA,SAAgB,iBACd,UACA;CACA,QAAQ,QAA6E;EACnF,IAAI,CAAC,KACH,SAAS,GAAQ;OACZ,IAAI,OAAO,QAAQ,YACxB,SAAS,GAAG;OACP,IAAI,OAAO,QAAQ,YAAY,iBAAiB,KAAK;GAC1D,MAAM,EAAE,kBAAkB;GAE1B,IAAI,cAAc,SAAS,YACzB,SAAU,cAAsB,OAAc;QAE9C,SAAS,cAAc,KAAY;EAEvC,OACE,SAAS,GAAG;CAEhB;AACF;AAOA,SAAgB,cAAiB,cAA8C;CAC7E,MAAM,CAAC,OAAO,aAAA,GAAA,MAAA,UAAwB,YAAY;CAClD,OAAO,CAAC,OAAO,iBAAoB,QAAe,CAAC;AACrD"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-intersection/use-intersection.cjs

@@ -0,0 +1,32 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-intersection/use-intersection.ts
+function useIntersection(options) {
+	const [entry, setEntry] = (0, react.useState)(null);
+	const observer = (0, react.useRef)(null);
+	return {
+		ref: (0, react.useCallback)((element) => {
+			if (observer.current) {
+				observer.current.disconnect();
+				observer.current = null;
+			}
+			if (element === null) {
+				setEntry(null);
+				return;
+			}
+			observer.current = new IntersectionObserver(([_entry]) => {
+				setEntry(_entry);
+			}, options);
+			observer.current.observe(element);
+		}, [
+			options?.rootMargin,
+			options?.root,
+			options?.threshold
+		]),
+		entry
+	};
+}
+//#endregion
+exports.useIntersection = useIntersection;
+
+//# sourceMappingURL=use-intersection.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-intersection/use-intersection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-intersection.cjs","names":[],"sources":["../../src/use-intersection/use-intersection.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nexport interface UseIntersectionReturnValue<T> {\n  ref: React.RefCallback<T | null>;\n  entry: IntersectionObserverEntry | null;\n}\n\nexport function useIntersection<T extends HTMLElement = any>(\n  options?: IntersectionObserverInit\n): UseIntersectionReturnValue<T> {\n  const [entry, setEntry] = useState<IntersectionObserverEntry | null>(null);\n\n  const observer = useRef<IntersectionObserver | null>(null);\n\n  const ref: React.RefCallback<T | null> = useCallback(\n    (element) => {\n      if (observer.current) {\n        observer.current.disconnect();\n        observer.current = null;\n      }\n\n      if (element === null) {\n        setEntry(null);\n        return;\n      }\n\n      observer.current = new IntersectionObserver(([_entry]) => {\n        setEntry(_entry);\n      }, options);\n\n      observer.current.observe(element);\n    },\n    [options?.rootMargin, options?.root, options?.threshold]\n  );\n\n  return { ref, entry };\n}\n\nexport namespace useIntersection {\n  export type ReturnValue<T> = UseIntersectionReturnValue<T>;\n}\n"],"mappings":";;;AAOA,SAAgB,gBACd,SAC+B;CAC/B,MAAM,CAAC,OAAO,aAAA,GAAA,MAAA,UAAuD,IAAI;CAEzE,MAAM,YAAA,GAAA,MAAA,QAA+C,IAAI;CAuBzD,OAAO;EAAE,MAAA,GAAA,MAAA,cApBN,YAAY;GACX,IAAI,SAAS,SAAS;IACpB,SAAS,QAAQ,WAAW;IAC5B,SAAS,UAAU;GACrB;GAEA,IAAI,YAAY,MAAM;IACpB,SAAS,IAAI;IACb;GACF;GAEA,SAAS,UAAU,IAAI,sBAAsB,CAAC,YAAY;IACxD,SAAS,MAAM;GACjB,GAAG,OAAO;GAEV,SAAS,QAAQ,QAAQ,OAAO;EAClC,GACA;GAAC,SAAS;GAAY,SAAS;GAAM,SAAS;EAAS,CAG9C;EAAG;CAAM;AACtB"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-interval/use-interval.cjs

@@ -0,0 +1,54 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-interval/use-interval.ts
+function useInterval(fn, interval, { autoInvoke = false } = {}) {
+	const [active, setActive] = (0, react.useState)(false);
+	const intervalRef = (0, react.useRef)(null);
+	const fnRef = (0, react.useRef)(null);
+	const intervalValueRef = (0, react.useRef)(interval);
+	intervalValueRef.current = interval;
+	const start = (0, react.useCallback)(() => {
+		setActive((old) => {
+			if (!old && !intervalRef.current) intervalRef.current = window.setInterval(fnRef.current, intervalValueRef.current);
+			return true;
+		});
+	}, []);
+	const stop = (0, react.useCallback)(() => {
+		setActive(false);
+		if (intervalRef.current) window.clearInterval(intervalRef.current);
+		intervalRef.current = null;
+	}, []);
+	const toggle = (0, react.useCallback)(() => {
+		setActive((current) => {
+			if (current) {
+				if (intervalRef.current) window.clearInterval(intervalRef.current);
+				intervalRef.current = null;
+				return false;
+			}
+			if (!intervalRef.current) intervalRef.current = window.setInterval(fnRef.current, intervalValueRef.current);
+			return true;
+		});
+	}, []);
+	(0, react.useEffect)(() => {
+		fnRef.current = fn;
+		active && start();
+		return stop;
+	}, [
+		fn,
+		active,
+		interval
+	]);
+	(0, react.useEffect)(() => {
+		if (autoInvoke) start();
+	}, []);
+	return {
+		start,
+		stop,
+		toggle,
+		active
+	};
+}
+//#endregion
+exports.useInterval = useInterval;
+
+//# sourceMappingURL=use-interval.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-interval/use-interval.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interval.cjs","names":[],"sources":["../../src/use-interval/use-interval.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\n\nexport interface UseIntervalOptions {\n  /** If set, the interval will start automatically when the component is mounted, `false` by default */\n  autoInvoke?: boolean;\n}\n\nexport interface UseIntervalReturnValue {\n  /** Starts the interval */\n  start: () => void;\n\n  /** Stops the interval */\n  stop: () => void;\n\n  /** Toggles the interval */\n  toggle: () => void;\n\n  /** Indicates if the interval is active */\n  active: boolean;\n}\n\nexport function useInterval(\n  fn: () => void,\n  interval: number,\n  { autoInvoke = false }: UseIntervalOptions = {}\n): UseIntervalReturnValue {\n  const [active, setActive] = useState(false);\n  const intervalRef = useRef<number | null>(null);\n  const fnRef = useRef<() => void>(null);\n  const intervalValueRef = useRef(interval);\n  intervalValueRef.current = interval;\n\n  const start = useCallback(() => {\n    setActive((old) => {\n      if (!old && !intervalRef.current) {\n        intervalRef.current = window.setInterval(fnRef.current!, intervalValueRef.current);\n      }\n      return true;\n    });\n  }, []);\n\n  const stop = useCallback(() => {\n    setActive(false);\n    if (intervalRef.current) {\n      window.clearInterval(intervalRef.current);\n    }\n    intervalRef.current = null;\n  }, []);\n\n  const toggle = useCallback(() => {\n    setActive((current) => {\n      if (current) {\n        if (intervalRef.current) {\n          window.clearInterval(intervalRef.current);\n        }\n        intervalRef.current = null;\n        return false;\n      }\n      if (!intervalRef.current) {\n        intervalRef.current = window.setInterval(fnRef.current!, intervalValueRef.current);\n      }\n      return true;\n    });\n  }, []);\n\n  useEffect(() => {\n    fnRef.current = fn;\n    active && start();\n    return stop;\n  }, [fn, active, interval]);\n\n  useEffect(() => {\n    if (autoInvoke) {\n      start();\n    }\n  }, []);\n\n  return { start, stop, toggle, active };\n}\n\nexport namespace useInterval {\n  export type Options = UseIntervalOptions;\n  export type ReturnValue = UseIntervalReturnValue;\n}\n"],"mappings":";;;AAqBA,SAAgB,YACd,IACA,UACA,EAAE,aAAa,UAA8B,CAAC,GACtB;CACxB,MAAM,CAAC,QAAQ,cAAA,GAAA,MAAA,UAAsB,KAAK;CAC1C,MAAM,eAAA,GAAA,MAAA,QAAoC,IAAI;CAC9C,MAAM,SAAA,GAAA,MAAA,QAA2B,IAAI;CACrC,MAAM,oBAAA,GAAA,MAAA,QAA0B,QAAQ;CACxC,iBAAiB,UAAU;CAE3B,MAAM,SAAA,GAAA,MAAA,mBAA0B;EAC9B,WAAW,QAAQ;GACjB,IAAI,CAAC,OAAO,CAAC,YAAY,SACvB,YAAY,UAAU,OAAO,YAAY,MAAM,SAAU,iBAAiB,OAAO;GAEnF,OAAO;EACT,CAAC;CACH,GAAG,CAAC,CAAC;CAEL,MAAM,QAAA,GAAA,MAAA,mBAAyB;EAC7B,UAAU,KAAK;EACf,IAAI,YAAY,SACd,OAAO,cAAc,YAAY,OAAO;EAE1C,YAAY,UAAU;CACxB,GAAG,CAAC,CAAC;CAEL,MAAM,UAAA,GAAA,MAAA,mBAA2B;EAC/B,WAAW,YAAY;GACrB,IAAI,SAAS;IACX,IAAI,YAAY,SACd,OAAO,cAAc,YAAY,OAAO;IAE1C,YAAY,UAAU;IACtB,OAAO;GACT;GACA,IAAI,CAAC,YAAY,SACf,YAAY,UAAU,OAAO,YAAY,MAAM,SAAU,iBAAiB,OAAO;GAEnF,OAAO;EACT,CAAC;CACH,GAAG,CAAC,CAAC;CAEL,CAAA,GAAA,MAAA,iBAAgB;EACd,MAAM,UAAU;EAChB,UAAU,MAAM;EAChB,OAAO;CACT,GAAG;EAAC;EAAI;EAAQ;CAAQ,CAAC;CAEzB,CAAA,GAAA,MAAA,iBAAgB;EACd,IAAI,YACF,MAAM;CAEV,GAAG,CAAC,CAAC;CAEL,OAAO;EAAE;EAAO;EAAM;EAAQ;CAAO;AACvC"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-is-first-render/use-is-first-render.cjs

@@ -0,0 +1,15 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-is-first-render/use-is-first-render.ts
+function useIsFirstRender() {
+	const renderRef = (0, react.useRef)(true);
+	if (renderRef.current === true) {
+		renderRef.current = false;
+		return true;
+	}
+	return renderRef.current;
+}
+//#endregion
+exports.useIsFirstRender = useIsFirstRender;
+
+//# sourceMappingURL=use-is-first-render.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-is-first-render/use-is-first-render.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-is-first-render.cjs","names":[],"sources":["../../src/use-is-first-render/use-is-first-render.ts"],"sourcesContent":["import { useRef } from 'react';\n\nexport function useIsFirstRender() {\n  const renderRef = useRef(true);\n\n  if (renderRef.current === true) {\n    renderRef.current = false;\n    return true;\n  }\n\n  return renderRef.current;\n}\n"],"mappings":";;;AAEA,SAAgB,mBAAmB;CACjC,MAAM,aAAA,GAAA,MAAA,QAAmB,IAAI;CAE7B,IAAI,UAAU,YAAY,MAAM;EAC9B,UAAU,UAAU;EACpB,OAAO;CACT;CAEA,OAAO,UAAU;AACnB"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-isomorphic-effect/use-isomorphic-effect.cjs

@@ -0,0 +1,8 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-isomorphic-effect/use-isomorphic-effect.ts
+const useIsomorphicEffect = typeof document !== "undefined" ? react.useLayoutEffect : react.useEffect;
+//#endregion
+exports.useIsomorphicEffect = useIsomorphicEffect;
+
+//# sourceMappingURL=use-isomorphic-effect.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-isomorphic-effect/use-isomorphic-effect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-isomorphic-effect.cjs","names":["useLayoutEffect","useEffect"],"sources":["../../src/use-isomorphic-effect/use-isomorphic-effect.ts"],"sourcesContent":["import { useEffect, useLayoutEffect } from 'react';\n\n// UseLayoutEffect will show warning if used during ssr, for example with Next.js\n// UseIsomorphicEffect removes it by replacing useLayoutEffect with useEffect during ssr\nexport const useIsomorphicEffect = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n"],"mappings":";;;AAIA,MAAa,sBAAsB,OAAO,aAAa,cAAcA,MAAAA,kBAAkBC,MAAAA"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-list-state/use-list-state.cjs

@@ -0,0 +1,77 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-list-state/use-list-state.ts
+function useListState(initialValue = []) {
+	const [state, setState] = (0, react.useState)(initialValue);
+	const append = (0, react.useCallback)((...items) => setState((current) => [...current, ...items]), []);
+	const prepend = (0, react.useCallback)((...items) => setState((current) => [...items, ...current]), []);
+	const insert = (0, react.useCallback)((index, ...items) => setState((current) => [
+		...current.slice(0, index),
+		...items,
+		...current.slice(index)
+	]), []);
+	const apply = (0, react.useCallback)((fn) => setState((current) => current.map((item, index) => fn(item, index))), []);
+	const remove = (0, react.useCallback)((...indices) => setState((current) => current.filter((_, index) => !indices.includes(index))), []);
+	const pop = (0, react.useCallback)(() => setState((current) => {
+		const cloned = [...current];
+		cloned.pop();
+		return cloned;
+	}), []);
+	const shift = (0, react.useCallback)(() => setState((current) => {
+		const cloned = [...current];
+		cloned.shift();
+		return cloned;
+	}), []);
+	const reorder = (0, react.useCallback)(({ from, to }) => setState((current) => {
+		const cloned = [...current];
+		const item = current[from];
+		cloned.splice(from, 1);
+		cloned.splice(to, 0, item);
+		return cloned;
+	}), []);
+	const swap = (0, react.useCallback)(({ from, to }) => setState((current) => {
+		const cloned = [...current];
+		const fromItem = cloned[from];
+		const toItem = cloned[to];
+		cloned.splice(to, 1, fromItem);
+		cloned.splice(from, 1, toItem);
+		return cloned;
+	}), []);
+	const setItem = (0, react.useCallback)((index, item) => setState((current) => {
+		const cloned = [...current];
+		cloned[index] = item;
+		return cloned;
+	}), []);
+	const setItemProp = (0, react.useCallback)((index, prop, value) => setState((current) => {
+		const cloned = [...current];
+		cloned[index] = {
+			...cloned[index],
+			[prop]: value
+		};
+		return cloned;
+	}), []);
+	const applyWhere = (0, react.useCallback)((condition, fn) => setState((current) => current.map((item, index) => condition(item, index) ? fn(item, index) : item)), []);
+	const filter = (0, react.useCallback)((fn) => {
+		setState((current) => current.filter(fn));
+	}, []);
+	return [state, (0, react.useMemo)(() => ({
+		setState,
+		append,
+		prepend,
+		insert,
+		pop,
+		shift,
+		apply,
+		applyWhere,
+		remove,
+		reorder,
+		swap,
+		setItem,
+		setItemProp,
+		filter
+	}), [])];
+}
+//#endregion
+exports.useListState = useListState;
+
+//# sourceMappingURL=use-list-state.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-local-storage/create-storage.cjs

@@ -0,0 +1,139 @@
+"use client";
+const require_use_window_event = require("../use-window-event/use-window-event.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-local-storage/create-storage.ts
+function serializeJSON(value, hookName = "use-local-storage") {
+	try {
+		return JSON.stringify(value);
+	} catch (error) {
+		throw new Error(`@mantine/hooks ${hookName}: Failed to serialize the value`);
+	}
+}
+function deserializeJSON(value) {
+	try {
+		return value && JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function createStorageHandler(type) {
+	const getItem = (key) => {
+		try {
+			return window[type].getItem(key);
+		} catch (error) {
+			console.warn("use-local-storage: Failed to get value from storage, localStorage is blocked");
+			return null;
+		}
+	};
+	const setItem = (key, value) => {
+		try {
+			window[type].setItem(key, value);
+		} catch (error) {
+			console.warn("use-local-storage: Failed to set value to storage, localStorage is blocked");
+		}
+	};
+	const removeItem = (key) => {
+		try {
+			window[type].removeItem(key);
+		} catch (error) {
+			console.warn("use-local-storage: Failed to remove value from storage, localStorage is blocked");
+		}
+	};
+	return {
+		getItem,
+		setItem,
+		removeItem
+	};
+}
+function createStorage(type, hookName) {
+	const eventName = type === "localStorage" ? "mantine-local-storage" : "mantine-session-storage";
+	const { getItem, setItem, removeItem } = createStorageHandler(type);
+	return function useStorage({ key, defaultValue, getInitialValueInEffect = true, sync = true, deserialize = deserializeJSON, serialize = (value) => serializeJSON(value, hookName) }) {
+		const readStorageValue = (0, react.useCallback)((skipStorage) => {
+			let storageBlockedOrSkipped;
+			try {
+				storageBlockedOrSkipped = typeof window === "undefined" || !(type in window) || window[type] === null || !!skipStorage;
+			} catch (_e) {
+				storageBlockedOrSkipped = true;
+			}
+			if (storageBlockedOrSkipped) return defaultValue;
+			const storageValue = getItem(key);
+			return storageValue !== null ? deserialize(storageValue) : defaultValue;
+		}, [key, defaultValue]);
+		const [value, setValue] = (0, react.useState)(readStorageValue(getInitialValueInEffect));
+		const setStorageValue = (0, react.useCallback)((val) => {
+			if (val instanceof Function) setValue((current) => {
+				const result = val(current);
+				setItem(key, serialize(result));
+				queueMicrotask(() => {
+					window.dispatchEvent(new CustomEvent(eventName, { detail: {
+						key,
+						value: result
+					} }));
+				});
+				return result;
+			});
+			else {
+				setItem(key, serialize(val));
+				window.dispatchEvent(new CustomEvent(eventName, { detail: {
+					key,
+					value: val
+				} }));
+				setValue(val);
+			}
+		}, [key]);
+		const removeStorageValue = (0, react.useCallback)(() => {
+			removeItem(key);
+			setValue(defaultValue);
+			window.dispatchEvent(new CustomEvent(eventName, { detail: {
+				key,
+				value: defaultValue
+			} }));
+		}, [key, defaultValue]);
+		require_use_window_event.useWindowEvent("storage", (event) => {
+			if (sync) {
+				if (event.storageArea === window[type] && event.key === key) setValue(deserialize(event.newValue ?? void 0));
+			}
+		});
+		require_use_window_event.useWindowEvent(eventName, (event) => {
+			if (sync) {
+				if (event.detail.key === key) setValue(event.detail.value);
+			}
+		});
+		(0, react.useEffect)(() => {
+			if (defaultValue !== void 0 && value === void 0) setStorageValue(defaultValue);
+		}, [
+			defaultValue,
+			value,
+			setStorageValue
+		]);
+		(0, react.useEffect)(() => {
+			const val = readStorageValue();
+			val !== void 0 && setStorageValue(val);
+		}, [key]);
+		return [
+			value === void 0 ? defaultValue : value,
+			setStorageValue,
+			removeStorageValue
+		];
+	};
+}
+function readValue(type) {
+	const { getItem } = createStorageHandler(type);
+	return function read({ key, defaultValue, deserialize = deserializeJSON }) {
+		let storageBlockedOrSkipped;
+		try {
+			storageBlockedOrSkipped = typeof window === "undefined" || !(type in window) || window[type] === null;
+		} catch (_e) {
+			storageBlockedOrSkipped = true;
+		}
+		if (storageBlockedOrSkipped) return defaultValue;
+		const storageValue = getItem(key);
+		return storageValue !== null ? deserialize(storageValue) : defaultValue;
+	};
+}
+//#endregion
+exports.createStorage = createStorage;
+exports.readValue = readValue;
+
+//# sourceMappingURL=create-storage.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-local-storage/use-local-storage.cjs

@@ -0,0 +1,12 @@
+"use client";
+const require_create_storage = require("./create-storage.cjs");
+//#region packages/@mantine/hooks/src/use-local-storage/use-local-storage.ts
+function useLocalStorage(props) {
+	return require_create_storage.createStorage("localStorage", "use-local-storage")(props);
+}
+const readLocalStorageValue = require_create_storage.readValue("localStorage");
+//#endregion
+exports.readLocalStorageValue = readLocalStorageValue;
+exports.useLocalStorage = useLocalStorage;
+
+//# sourceMappingURL=use-local-storage.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-local-storage/use-local-storage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-local-storage.cjs","names":["createStorage","readValue"],"sources":["../../src/use-local-storage/use-local-storage.ts"],"sourcesContent":["import {\n  createStorage,\n  readValue,\n  UseStorageOptions,\n  UseStorageReturnValue,\n} from './create-storage';\n\nexport function useLocalStorage<T = string>(\n  props: UseStorageOptions<T> & { defaultValue: T }\n): UseStorageReturnValue<T>;\nexport function useLocalStorage<T = string>(\n  props: UseStorageOptions<T>\n): UseStorageReturnValue<T | undefined>;\nexport function useLocalStorage<T = string>(props: UseStorageOptions<T>) {\n  return createStorage<T>('localStorage', 'use-local-storage')(props);\n}\n\ninterface ReadStorageValue {\n  <T>(options: UseStorageOptions<T> & { defaultValue: T }): T;\n  <T>(options: UseStorageOptions<T>): T | undefined;\n}\n\nexport const readLocalStorageValue: ReadStorageValue = readValue('localStorage');\n"],"mappings":";;;AAaA,SAAgB,gBAA4B,OAA6B;CACvE,OAAOA,uBAAAA,cAAiB,gBAAgB,mBAAmB,EAAE,KAAK;AACpE;AAOA,MAAa,wBAA0CC,uBAAAA,UAAU,cAAc"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-logger/use-logger.cjs

@@ -0,0 +1,18 @@
+"use client";
+const require_use_did_update = require("../use-did-update/use-did-update.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-logger/use-logger.ts
+function useLogger(componentName, props) {
+	(0, react.useEffect)(() => {
+		console.log(`${componentName} mounted`, ...props);
+		return () => console.log(`${componentName} unmounted`);
+	}, []);
+	require_use_did_update.useDidUpdate(() => {
+		console.log(`${componentName} updated`, ...props);
+	}, props);
+	return null;
+}
+//#endregion
+exports.useLogger = useLogger;
+
+//# sourceMappingURL=use-logger.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-logger/use-logger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-logger.cjs","names":[],"sources":["../../src/use-logger/use-logger.ts"],"sourcesContent":["/* oxlint-disable no-console */\nimport { useEffect } from 'react';\nimport { useDidUpdate } from '../use-did-update/use-did-update';\n\nexport function useLogger(componentName: string, props: any[]) {\n  useEffect(() => {\n    console.log(`${componentName} mounted`, ...props);\n    return () => console.log(`${componentName} unmounted`);\n  }, []);\n\n  useDidUpdate(() => {\n    console.log(`${componentName} updated`, ...props);\n  }, props);\n\n  return null;\n}\n"],"mappings":";;;;AAIA,SAAgB,UAAU,eAAuB,OAAc;CAC7D,CAAA,GAAA,MAAA,iBAAgB;EACd,QAAQ,IAAI,GAAG,cAAc,WAAW,GAAG,KAAK;EAChD,aAAa,QAAQ,IAAI,GAAG,cAAc,WAAW;CACvD,GAAG,CAAC,CAAC;CAEL,uBAAA,mBAAmB;EACjB,QAAQ,IAAI,GAAG,cAAc,WAAW,GAAG,KAAK;CAClD,GAAG,KAAK;CAER,OAAO;AACT"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-long-press/use-long-press.cjs

@@ -0,0 +1,60 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-long-press/use-long-press.ts
+function useLongPress(onLongPress, options = {}) {
+	const { threshold = 400, onStart, onFinish, onCancel } = options;
+	const isLongPressActive = (0, react.useRef)(false);
+	const isPressed = (0, react.useRef)(false);
+	const timeout = (0, react.useRef)(-1);
+	(0, react.useEffect)(() => () => window.clearTimeout(timeout.current), []);
+	return (0, react.useMemo)(() => {
+		if (typeof onLongPress !== "function") return {};
+		const start = (event) => {
+			if (!isMouseEvent(event) && !isTouchEvent(event)) return;
+			if (onStart) onStart(event);
+			isPressed.current = true;
+			timeout.current = window.setTimeout(() => {
+				onLongPress(event);
+				isLongPressActive.current = true;
+			}, threshold);
+		};
+		const cancel = (event) => {
+			if (!isMouseEvent(event) && !isTouchEvent(event)) return;
+			if (isLongPressActive.current) {
+				if (onFinish) onFinish(event);
+			} else if (isPressed.current) {
+				if (onCancel) onCancel(event);
+			}
+			isLongPressActive.current = false;
+			isPressed.current = false;
+			if (timeout.current !== -1) {
+				window.clearTimeout(timeout.current);
+				timeout.current = -1;
+			}
+		};
+		return {
+			onMouseDown: start,
+			onMouseUp: cancel,
+			onMouseLeave: cancel,
+			onTouchStart: start,
+			onTouchEnd: cancel,
+			onTouchCancel: cancel
+		};
+	}, [
+		onLongPress,
+		threshold,
+		onCancel,
+		onFinish,
+		onStart
+	]);
+}
+function isTouchEvent(event) {
+	return window.TouchEvent ? event.nativeEvent instanceof TouchEvent : "touches" in event.nativeEvent;
+}
+function isMouseEvent(event) {
+	return event.nativeEvent instanceof MouseEvent;
+}
+//#endregion
+exports.useLongPress = useLongPress;
+
+//# sourceMappingURL=use-long-press.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-long-press/use-long-press.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-long-press.cjs","names":[],"sources":["../../src/use-long-press/use-long-press.ts"],"sourcesContent":["import React, { useEffect, useMemo, useRef } from 'react';\n\nexport interface UseLongPressOptions {\n  /** Time in milliseconds to trigger the long press, default is 400ms */\n  threshold?: number;\n\n  /** Callback triggered when the long press starts */\n  onStart?: (event: React.MouseEvent | React.TouchEvent) => void;\n\n  /** Callback triggered when the long press finishes */\n  onFinish?: (event: React.MouseEvent | React.TouchEvent) => void;\n\n  /** Callback triggered when the long press is canceled */\n  onCancel?: (event: React.MouseEvent | React.TouchEvent) => void;\n}\n\nexport interface UseLongPressReturnValue {\n  onMouseDown: (event: React.MouseEvent) => void;\n  onMouseUp: (event: React.MouseEvent) => void;\n  onMouseLeave: (event: React.MouseEvent) => void;\n  onTouchStart: (event: React.TouchEvent) => void;\n  onTouchEnd: (event: React.TouchEvent) => void;\n  onTouchCancel: (event: React.TouchEvent) => void;\n}\n\nexport function useLongPress(\n  onLongPress: (event: React.MouseEvent | React.TouchEvent) => void,\n  options: UseLongPressOptions = {}\n): UseLongPressReturnValue {\n  const { threshold = 400, onStart, onFinish, onCancel } = options;\n  const isLongPressActive = useRef(false);\n  const isPressed = useRef(false);\n  const timeout = useRef<number>(-1);\n\n  useEffect(() => () => window.clearTimeout(timeout.current), []);\n\n  return useMemo(() => {\n    if (typeof onLongPress !== 'function') {\n      return {} as UseLongPressReturnValue;\n    }\n\n    const start = (event: React.MouseEvent | React.TouchEvent) => {\n      if (!isMouseEvent(event) && !isTouchEvent(event)) {\n        return;\n      }\n\n      if (onStart) {\n        onStart(event);\n      }\n\n      isPressed.current = true;\n      timeout.current = window.setTimeout(() => {\n        onLongPress(event);\n        isLongPressActive.current = true;\n      }, threshold);\n    };\n\n    const cancel = (event: React.MouseEvent | React.TouchEvent) => {\n      if (!isMouseEvent(event) && !isTouchEvent(event)) {\n        return;\n      }\n\n      if (isLongPressActive.current) {\n        if (onFinish) {\n          onFinish(event);\n        }\n      } else if (isPressed.current) {\n        if (onCancel) {\n          onCancel(event);\n        }\n      }\n\n      isLongPressActive.current = false;\n      isPressed.current = false;\n\n      if (timeout.current !== -1) {\n        window.clearTimeout(timeout.current);\n        timeout.current = -1;\n      }\n    };\n\n    return {\n      onMouseDown: start,\n      onMouseUp: cancel,\n      onMouseLeave: cancel,\n      onTouchStart: start,\n      onTouchEnd: cancel,\n      onTouchCancel: cancel,\n    };\n  }, [onLongPress, threshold, onCancel, onFinish, onStart]);\n}\n\nfunction isTouchEvent(event: React.MouseEvent | React.TouchEvent): event is React.TouchEvent {\n  return window.TouchEvent\n    ? event.nativeEvent instanceof TouchEvent\n    : 'touches' in event.nativeEvent;\n}\n\nfunction isMouseEvent(event: React.MouseEvent | React.TouchEvent): event is React.MouseEvent {\n  return event.nativeEvent instanceof MouseEvent;\n}\n\nexport namespace useLongPress {\n  export type Options = UseLongPressOptions;\n  export type ReturnValue = UseLongPressReturnValue;\n}\n"],"mappings":";;;AAyBA,SAAgB,aACd,aACA,UAA+B,CAAC,GACP;CACzB,MAAM,EAAE,YAAY,KAAK,SAAS,UAAU,aAAa;CACzD,MAAM,qBAAA,GAAA,MAAA,QAA2B,KAAK;CACtC,MAAM,aAAA,GAAA,MAAA,QAAmB,KAAK;CAC9B,MAAM,WAAA,GAAA,MAAA,QAAyB,EAAE;CAEjC,CAAA,GAAA,MAAA,uBAAsB,OAAO,aAAa,QAAQ,OAAO,GAAG,CAAC,CAAC;CAE9D,QAAA,GAAA,MAAA,eAAqB;EACnB,IAAI,OAAO,gBAAgB,YACzB,OAAO,CAAC;EAGV,MAAM,SAAS,UAA+C;GAC5D,IAAI,CAAC,aAAa,KAAK,KAAK,CAAC,aAAa,KAAK,GAC7C;GAGF,IAAI,SACF,QAAQ,KAAK;GAGf,UAAU,UAAU;GACpB,QAAQ,UAAU,OAAO,iBAAiB;IACxC,YAAY,KAAK;IACjB,kBAAkB,UAAU;GAC9B,GAAG,SAAS;EACd;EAEA,MAAM,UAAU,UAA+C;GAC7D,IAAI,CAAC,aAAa,KAAK,KAAK,CAAC,aAAa,KAAK,GAC7C;GAGF,IAAI,kBAAkB;QAChB,UACF,SAAS,KAAK;GAAA,OAEX,IAAI,UAAU;QACf,UACF,SAAS,KAAK;GAAA;GAIlB,kBAAkB,UAAU;GAC5B,UAAU,UAAU;GAEpB,IAAI,QAAQ,YAAY,IAAI;IAC1B,OAAO,aAAa,QAAQ,OAAO;IACnC,QAAQ,UAAU;GACpB;EACF;EAEA,OAAO;GACL,aAAa;GACb,WAAW;GACX,cAAc;GACd,cAAc;GACd,YAAY;GACZ,eAAe;EACjB;CACF,GAAG;EAAC;EAAa;EAAW;EAAU;EAAU;CAAO,CAAC;AAC1D;AAEA,SAAS,aAAa,OAAuE;CAC3F,OAAO,OAAO,aACV,MAAM,uBAAuB,aAC7B,aAAa,MAAM;AACzB;AAEA,SAAS,aAAa,OAAuE;CAC3F,OAAO,MAAM,uBAAuB;AACtC"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-map/use-map.cjs

@@ -0,0 +1,27 @@
+"use client";
+const require_use_force_update = require("../use-force-update/use-force-update.cjs");
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-map/use-map.ts
+function useMap(initialState) {
+	const mapRef = (0, react.useRef)(new Map(initialState));
+	const forceUpdate = require_use_force_update.useForceUpdate();
+	mapRef.current.set = (...args) => {
+		Map.prototype.set.apply(mapRef.current, args);
+		forceUpdate();
+		return mapRef.current;
+	};
+	mapRef.current.clear = (...args) => {
+		Map.prototype.clear.apply(mapRef.current, args);
+		forceUpdate();
+	};
+	mapRef.current.delete = (...args) => {
+		const res = Map.prototype.delete.apply(mapRef.current, args);
+		forceUpdate();
+		return res;
+	};
+	return mapRef.current;
+}
+//#endregion
+exports.useMap = useMap;
+
+//# sourceMappingURL=use-map.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-map/use-map.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-map.cjs","names":["useForceUpdate"],"sources":["../../src/use-map/use-map.ts"],"sourcesContent":["import { useRef } from 'react';\nimport { useForceUpdate } from '../use-force-update/use-force-update';\n\nexport function useMap<T, V>(initialState?: [T, V][]): Map<T, V> {\n  const mapRef = useRef(new Map<T, V>(initialState));\n  const forceUpdate = useForceUpdate();\n\n  mapRef.current.set = (...args) => {\n    Map.prototype.set.apply(mapRef.current, args);\n    forceUpdate();\n    return mapRef.current;\n  };\n\n  mapRef.current.clear = (...args) => {\n    Map.prototype.clear.apply(mapRef.current, args);\n    forceUpdate();\n  };\n\n  mapRef.current.delete = (...args) => {\n    const res = Map.prototype.delete.apply(mapRef.current, args);\n    forceUpdate();\n\n    return res;\n  };\n\n  return mapRef.current;\n}\n"],"mappings":";;;;AAGA,SAAgB,OAAa,cAAoC;CAC/D,MAAM,UAAA,GAAA,MAAA,QAAgB,IAAI,IAAU,YAAY,CAAC;CACjD,MAAM,cAAcA,yBAAAA,eAAe;CAEnC,OAAO,QAAQ,OAAO,GAAG,SAAS;EAChC,IAAI,UAAU,IAAI,MAAM,OAAO,SAAS,IAAI;EAC5C,YAAY;EACZ,OAAO,OAAO;CAChB;CAEA,OAAO,QAAQ,SAAS,GAAG,SAAS;EAClC,IAAI,UAAU,MAAM,MAAM,OAAO,SAAS,IAAI;EAC9C,YAAY;CACd;CAEA,OAAO,QAAQ,UAAU,GAAG,SAAS;EACnC,MAAM,MAAM,IAAI,UAAU,OAAO,MAAM,OAAO,SAAS,IAAI;EAC3D,YAAY;EAEZ,OAAO;CACT;CAEA,OAAO,OAAO;AAChB"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-mask/use-mask.cjs

@@ -0,0 +1,582 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-mask/use-mask.ts
+const DEFAULT_TOKENS = {
+	"9": /[0-9]/,
+	a: /[A-Za-z]/,
+	A: /[A-Z]/,
+	"*": /[A-Za-z0-9]/,
+	"#": /[-+0-9]/
+};
+const MAX_UNDO_HISTORY = 100;
+function parseMask(mask, tokens) {
+	if (Array.isArray(mask)) return mask.map((item) => {
+		if (item instanceof RegExp) return {
+			type: "token",
+			char: "_",
+			pattern: item
+		};
+		return {
+			type: "literal",
+			char: item
+		};
+	});
+	const slots = [];
+	let optional = false;
+	for (let i = 0; i < mask.length; i++) {
+		const char = mask[i];
+		if (char === "\\" && i + 1 < mask.length) {
+			i++;
+			slots.push({
+				type: "literal",
+				char: mask[i]
+			});
+			continue;
+		}
+		if (char === "?") {
+			optional = true;
+			continue;
+		}
+		if (tokens[char]) slots.push({
+			type: "token",
+			char,
+			pattern: tokens[char],
+			optional
+		});
+		else slots.push({
+			type: "literal",
+			char,
+			optional
+		});
+	}
+	return slots;
+}
+function getSlotChar(slotCharOption, index) {
+	if (slotCharOption === null || slotCharOption === "" || slotCharOption === void 0) return "";
+	if (slotCharOption.length > 1) return slotCharOption[index] || "_";
+	return slotCharOption;
+}
+function applyMaskToRaw(raw, slots, _slotCharOption, transform) {
+	let result = "";
+	let rawIndex = 0;
+	let slotIndex = 0;
+	for (slotIndex = 0; slotIndex < slots.length; slotIndex++) {
+		const slot = slots[slotIndex];
+		if (slot.type === "literal") result += slot.char;
+		else if (rawIndex < raw.length) {
+			const ch = transform ? transform(raw[rawIndex]) : raw[rawIndex];
+			if (slot.pattern && slot.pattern.test(ch)) {
+				result += ch;
+				rawIndex++;
+			} else {
+				rawIndex++;
+				slotIndex--;
+			}
+		} else break;
+	}
+	return result;
+}
+function buildDisplayValue(value, slots, slotCharOption, showSlots) {
+	if (!showSlots) return value;
+	let display = value;
+	for (let i = value.length; i < slots.length; i++) {
+		const slot = slots[i];
+		if (slot.type === "literal") display += slot.char;
+		else {
+			const sc = getSlotChar(slotCharOption, i);
+			if (!sc) break;
+			display += sc;
+		}
+	}
+	return display;
+}
+function extractRaw(masked, slots) {
+	let raw = "";
+	for (let i = 0; i < masked.length && i < slots.length; i++) if (slots[i].type === "token") raw += masked[i];
+	return raw;
+}
+function checkComplete(masked, slots) {
+	for (let i = 0; i < slots.length; i++) if (slots[i].type === "token" && !slots[i].optional) {
+		if (i >= masked.length) return false;
+		if (!slots[i].pattern.test(masked[i])) return false;
+	}
+	return true;
+}
+function findNextTokenIndex(slots, from) {
+	for (let i = from; i < slots.length; i++) if (slots[i].type === "token") return i;
+	return slots.length;
+}
+function findPrevTokenIndex(slots, from) {
+	for (let i = from; i >= 0; i--) if (slots[i].type === "token") return i;
+	return -1;
+}
+function processInput(inputValue, slots, _slotCharOption) {
+	let result = "";
+	let inputIndex = 0;
+	for (let slotIndex = 0; slotIndex < slots.length && inputIndex <= inputValue.length; slotIndex++) {
+		const slot = slots[slotIndex];
+		if (slot.type === "literal") {
+			result += slot.char;
+			if (inputIndex < inputValue.length && inputValue[inputIndex] === slot.char) inputIndex++;
+			continue;
+		}
+		if (inputIndex >= inputValue.length) break;
+		while (inputIndex < inputValue.length) {
+			const ch = inputValue[inputIndex];
+			inputIndex++;
+			if (slot.pattern.test(ch)) {
+				result += ch;
+				break;
+			}
+		}
+		if (result.length <= slotIndex) break;
+	}
+	return result;
+}
+function getResolvedOptions(options, rawValue) {
+	const tokens = {
+		...DEFAULT_TOKENS,
+		...options.tokens
+	};
+	let mask = options.mask;
+	let slotChar = options.slotChar === void 0 ? "_" : options.slotChar;
+	let separate = options.separate ?? false;
+	if (options.modify) {
+		const overrides = options.modify(rawValue);
+		if (overrides) {
+			if (overrides.mask !== void 0) mask = overrides.mask;
+			if (overrides.tokens !== void 0) Object.assign(tokens, overrides.tokens);
+			if (overrides.slotChar !== void 0) slotChar = overrides.slotChar;
+			if (overrides.separate !== void 0) separate = overrides.separate;
+		}
+	}
+	return {
+		slots: parseMask(mask, tokens),
+		slotChar,
+		separate,
+		tokens,
+		transform: options.transform
+	};
+}
+function formatMask(raw, options) {
+	const { slots, slotChar, transform } = getResolvedOptions(options, raw);
+	return applyMaskToRaw(raw, slots, slotChar, transform);
+}
+function unformatMask(masked, options) {
+	const { slots } = getResolvedOptions(options, "");
+	return extractRaw(masked, slots);
+}
+function isMaskComplete(masked, options) {
+	const { slots } = getResolvedOptions(options, "");
+	return checkComplete(masked, slots);
+}
+function generatePattern(mode, options) {
+	const { slots } = getResolvedOptions(options, "");
+	let pattern = "";
+	for (const slot of slots) if (slot.type === "literal") pattern += slot.char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	else {
+		const src = slot.pattern.source;
+		if (mode === "full-inexact") pattern += slot.optional ? `${src}?` : src;
+		else pattern += slot.optional ? `(${src})?` : `(${src})`;
+	}
+	return pattern;
+}
+function useMask(options) {
+	const optionsRef = (0, react.useRef)(options);
+	optionsRef.current = options;
+	const inputRef = (0, react.useRef)(null);
+	const [maskedValue, setMaskedValue] = (0, react.useState)("");
+	const [rawValue, setRawValue] = (0, react.useState)("");
+	const processedRef = (0, react.useRef)("");
+	const displayValueRef = (0, react.useRef)("");
+	const rawValueRef = (0, react.useRef)("");
+	const wasCompleteRef = (0, react.useRef)(false);
+	const isFocusedRef = (0, react.useRef)(false);
+	const undoStackRef = (0, react.useRef)([]);
+	const redoStackRef = (0, react.useRef)([]);
+	const getOptions = (0, react.useCallback)(() => {
+		const opts = optionsRef.current;
+		return getResolvedOptions(opts, rawValue);
+	}, [rawValue]);
+	const updateValue = (0, react.useCallback)((newMasked, cursorPos) => {
+		const opts = optionsRef.current;
+		const { slots } = getResolvedOptions(opts, extractRaw(newMasked, getResolvedOptions(opts, "").slots));
+		const { slots: resolvedSlots, slotChar } = getResolvedOptions(opts, extractRaw(newMasked, slots));
+		const reprocessed = processInput(newMasked, resolvedSlots, slotChar);
+		const newRaw = extractRaw(reprocessed, resolvedSlots);
+		const showSlots = opts.alwaysShowMask || isFocusedRef.current;
+		const showOnFocus = opts.showMaskOnFocus !== false;
+		const displayValue = buildDisplayValue(reprocessed, resolvedSlots, slotChar, showSlots && (showOnFocus || reprocessed.length > 0));
+		processedRef.current = reprocessed;
+		displayValueRef.current = displayValue;
+		rawValueRef.current = newRaw;
+		setMaskedValue(displayValue);
+		setRawValue(newRaw);
+		if (inputRef.current) {
+			inputRef.current.value = displayValue;
+			if (cursorPos !== void 0 && document.activeElement === inputRef.current) {
+				const pos = Math.min(cursorPos, reprocessed.length);
+				inputRef.current.setSelectionRange(pos, pos);
+			}
+		}
+		if (opts.onChangeRaw) opts.onChangeRaw(newRaw, displayValue);
+		const complete = checkComplete(reprocessed, resolvedSlots);
+		if (complete && !wasCompleteRef.current && opts.onComplete) opts.onComplete(displayValue, newRaw);
+		wasCompleteRef.current = complete;
+		return {
+			displayValue,
+			newRaw,
+			reprocessed,
+			resolvedSlots
+		};
+	}, [getOptions]);
+	const pushUndoState = (0, react.useCallback)(() => {
+		const selectionStart = inputRef.current?.selectionStart ?? rawValueRef.current.length;
+		const state = {
+			rawValue: rawValueRef.current,
+			selectionStart
+		};
+		const stack = undoStackRef.current;
+		const top = stack[stack.length - 1];
+		if (top && top.rawValue === state.rawValue && top.selectionStart === state.selectionStart) return;
+		stack.push(state);
+		if (stack.length > MAX_UNDO_HISTORY) stack.shift();
+		redoStackRef.current = [];
+	}, []);
+	const applyHistoryState = (0, react.useCallback)((target) => {
+		const opts = optionsRef.current;
+		const { slots, slotChar, transform } = getResolvedOptions(opts, target.rawValue);
+		updateValue(applyMaskToRaw(target.rawValue, slots, slotChar, transform), target.selectionStart);
+	}, [updateValue]);
+	const handleInput = (0, react.useCallback)((e) => {
+		const input = e.target;
+		const opts = optionsRef.current;
+		const { slots: resolvedSlots, slotChar, transform } = getResolvedOptions(opts, "");
+		const prev = displayValueRef.current;
+		const curr = input.value;
+		let prefixLen = 0;
+		const maxPrefix = Math.min(prev.length, curr.length);
+		while (prefixLen < maxPrefix && prev[prefixLen] === curr[prefixLen]) prefixLen++;
+		let suffixLen = 0;
+		const maxSuffix = Math.min(prev.length - prefixLen, curr.length - prefixLen);
+		while (suffixLen < maxSuffix && prev[prev.length - 1 - suffixLen] === curr[curr.length - 1 - suffixLen]) suffixLen++;
+		const insertedText = curr.slice(prefixLen, curr.length - suffixLen);
+		const removedEnd = prev.length - suffixLen;
+		const beforeRaw = extractRaw(prev.slice(0, prefixLen), resolvedSlots.slice(0, prefixLen));
+		const afterRaw = extractRaw(prev.slice(removedEnd), resolvedSlots.slice(removedEnd));
+		const reformatted = applyMaskToRaw(beforeRaw + insertedText + afterRaw, resolvedSlots, slotChar, transform);
+		const maskedPrefix = applyMaskToRaw(beforeRaw + insertedText, resolvedSlots, slotChar, transform);
+		if (reformatted !== prev) pushUndoState();
+		updateValue(reformatted, maskedPrefix.length);
+	}, [pushUndoState, updateValue]);
+	const clampCursorToProcessed = (0, react.useCallback)((input) => {
+		const start = input.selectionStart ?? 0;
+		if (start !== (input.selectionEnd ?? 0)) return;
+		const opts = optionsRef.current;
+		const { slots } = getResolvedOptions(opts, "");
+		const processed = processedRef.current;
+		const endPos = processed.length > 0 ? findNextEditablePosition(processed.length, slots, processed) : findNextTokenIndex(slots, 0);
+		const startPos = findNextTokenIndex(slots, 0);
+		if (start > endPos || start < startPos) input.setSelectionRange(endPos, endPos);
+	}, []);
+	const handleFocus = (0, react.useCallback)(() => {
+		isFocusedRef.current = true;
+		const opts = optionsRef.current;
+		const input = inputRef.current;
+		if (!input) return;
+		const { slots, slotChar } = getResolvedOptions(opts, "");
+		const showOnFocus = opts.showMaskOnFocus !== false;
+		const processed = processedRef.current;
+		if (showOnFocus || opts.alwaysShowMask) {
+			const display = buildDisplayValue(processed, slots, slotChar, true);
+			input.value = display;
+			displayValueRef.current = display;
+			setMaskedValue(display);
+		}
+		requestAnimationFrame(() => {
+			if (input === document.activeElement) clampCursorToProcessed(input);
+		});
+	}, [clampCursorToProcessed]);
+	const handleMouseUp = (0, react.useCallback)(() => {
+		const input = inputRef.current;
+		if (!input || input !== document.activeElement) return;
+		clampCursorToProcessed(input);
+	}, [clampCursorToProcessed]);
+	const handleMouseDown = (0, react.useCallback)(() => {
+		const input = inputRef.current;
+		if (!input) return;
+		requestAnimationFrame(() => {
+			if (input !== document.activeElement) return;
+			const start = input.selectionStart ?? 0;
+			if (start !== (input.selectionEnd ?? 0)) return;
+			const opts = optionsRef.current;
+			const { slots } = getResolvedOptions(opts, "");
+			const processed = processedRef.current;
+			const endPos = processed.length > 0 ? findNextEditablePosition(processed.length, slots, processed) : findNextTokenIndex(slots, 0);
+			if (start > endPos) input.setSelectionRange(endPos, endPos);
+		});
+	}, []);
+	const handleBlur = (0, react.useCallback)(() => {
+		isFocusedRef.current = false;
+		const opts = optionsRef.current;
+		const input = inputRef.current;
+		if (!input) return;
+		const { slots, slotChar } = getResolvedOptions(opts, rawValue);
+		const expectedFocusDisplay = buildDisplayValue(processedRef.current, slots, slotChar, true);
+		const processed = input.value === expectedFocusDisplay ? processedRef.current : processInput(input.value, slots, slotChar);
+		const complete = checkComplete(processed, slots);
+		if (opts.autoClear && !complete && processed.length > 0) {
+			input.value = "";
+			processedRef.current = "";
+			displayValueRef.current = "";
+			rawValueRef.current = "";
+			setMaskedValue("");
+			setRawValue("");
+			wasCompleteRef.current = false;
+			if (opts.onChangeRaw) opts.onChangeRaw("", "");
+			if (opts.alwaysShowMask) {
+				const emptyDisplay = buildDisplayValue("", slots, slotChar, true);
+				input.value = emptyDisplay;
+				displayValueRef.current = emptyDisplay;
+				setMaskedValue(emptyDisplay);
+			}
+			return;
+		}
+		if (!opts.alwaysShowMask && !complete) {
+			if (extractRaw(processed, slots).length === 0) {
+				input.value = "";
+				processedRef.current = "";
+				displayValueRef.current = "";
+				rawValueRef.current = "";
+				setMaskedValue("");
+				setRawValue("");
+				wasCompleteRef.current = false;
+				if (opts.onChangeRaw) opts.onChangeRaw("", "");
+				return;
+			}
+			const display = buildDisplayValue(processed, slots, slotChar, false);
+			input.value = display;
+			displayValueRef.current = display;
+			setMaskedValue(display);
+		}
+	}, [rawValue]);
+	const handleKeyDown = (0, react.useCallback)((e) => {
+		const input = e.target;
+		const opts = optionsRef.current;
+		const { slots, slotChar, transform } = getResolvedOptions(opts, rawValue);
+		const start = input.selectionStart ?? 0;
+		const end = input.selectionEnd ?? 0;
+		const processed = processedRef.current;
+		const modifier = e.metaKey || e.ctrlKey && !e.altKey;
+		const key = e.key.toLowerCase();
+		if (modifier && key === "z" && !e.shiftKey) {
+			e.preventDefault();
+			const prev = undoStackRef.current.pop();
+			if (!prev) return;
+			redoStackRef.current.push({
+				rawValue: rawValueRef.current,
+				selectionStart: input.selectionStart ?? 0
+			});
+			applyHistoryState(prev);
+			return;
+		}
+		if (modifier && (key === "z" && e.shiftKey || key === "y" && !e.shiftKey)) {
+			e.preventDefault();
+			const next = redoStackRef.current.pop();
+			if (!next) return;
+			undoStackRef.current.push({
+				rawValue: rawValueRef.current,
+				selectionStart: input.selectionStart ?? 0
+			});
+			applyHistoryState(next);
+			return;
+		}
+		if (e.key === "Backspace") {
+			e.preventDefault();
+			if (e.metaKey || e.ctrlKey && !e.altKey) {
+				const clampedStart = Math.min(start, processed.length);
+				const newValue = applyMaskToRaw(extractRaw(processed.slice(clampedStart), slots.slice(clampedStart)), slots, slotChar, transform);
+				pushUndoState();
+				updateValue(newValue, 0);
+				return;
+			}
+			if (start !== end) {
+				const clampedEnd = Math.min(end, processed.length);
+				const before = processed.slice(0, start);
+				const afterRaw = extractRaw(processed.slice(clampedEnd), slots.slice(clampedEnd));
+				const newValue = applyMaskToRaw(extractRaw(before, slots) + afterRaw, slots, slotChar, transform);
+				pushUndoState();
+				updateValue(newValue, start);
+				return;
+			}
+			if (start === 0) return;
+			let deletePos = start - 1;
+			while (deletePos >= 0 && slots[deletePos] && slots[deletePos].type === "literal") deletePos--;
+			if (deletePos < 0) return;
+			const newValue = applyMaskToRaw(extractRaw(processed.slice(0, deletePos), slots.slice(0, deletePos)) + extractRaw(processed.slice(deletePos + 1), slots.slice(deletePos + 1)), slots, slotChar, transform);
+			pushUndoState();
+			updateValue(newValue, deletePos);
+		} else if (e.key === "Delete") {
+			e.preventDefault();
+			if (start !== end) {
+				const clampedEnd = Math.min(end, processed.length);
+				const before = processed.slice(0, start);
+				const afterRaw = extractRaw(processed.slice(clampedEnd), slots.slice(clampedEnd));
+				const newValue = applyMaskToRaw(extractRaw(before, slots) + afterRaw, slots, slotChar, transform);
+				pushUndoState();
+				updateValue(newValue, start);
+				return;
+			}
+			let deletePos = start;
+			while (deletePos < slots.length && slots[deletePos] && slots[deletePos].type === "literal") deletePos++;
+			if (deletePos >= processed.length) return;
+			const newValue = applyMaskToRaw(extractRaw(processed.slice(0, start), slots.slice(0, start)) + extractRaw(processed.slice(deletePos + 1), slots.slice(deletePos + 1)), slots, slotChar, transform);
+			pushUndoState();
+			updateValue(newValue, start);
+		} else if (e.key === "ArrowRight" && !e.shiftKey) {
+			const nextPos = findNextEditablePosition(start + 1, slots, input.value);
+			if (nextPos !== start + 1) {
+				e.preventDefault();
+				input.setSelectionRange(nextPos, nextPos);
+			}
+		} else if (e.key === "ArrowLeft" && !e.shiftKey) {
+			if (start > 0) {
+				const prevToken = findPrevTokenIndex(slots, start - 1);
+				if (prevToken >= 0 && prevToken !== start - 1) {
+					e.preventDefault();
+					input.setSelectionRange(prevToken + 1, prevToken + 1);
+				}
+			}
+		} else if (e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+			e.preventDefault();
+			let insertPos = Math.min(start, processed.length);
+			while (insertPos < slots.length && slots[insertPos] && slots[insertPos].type === "literal") insertPos++;
+			if (insertPos >= slots.length) return;
+			const slot = slots[insertPos];
+			const ch = transform ? transform(e.key) : e.key;
+			if (!slot.pattern.test(ch)) return;
+			const beforeRaw = extractRaw(processed.slice(0, insertPos), slots.slice(0, insertPos));
+			const afterRaw = start < end ? extractRaw(processed.slice(Math.min(end, processed.length)), slots.slice(Math.min(end, processed.length))) : extractRaw(processed.slice(insertPos), slots.slice(insertPos));
+			const newValue = applyMaskToRaw(beforeRaw + ch + afterRaw, slots, slotChar, transform);
+			const newCursorPos = findNextEditablePosition(insertPos + 1, slots, newValue);
+			pushUndoState();
+			updateValue(newValue, newCursorPos);
+		}
+	}, [
+		applyHistoryState,
+		pushUndoState,
+		rawValue,
+		updateValue
+	]);
+	const handlePaste = (0, react.useCallback)((e) => {
+		e.preventDefault();
+		const input = e.target;
+		const opts = optionsRef.current;
+		const pastedText = e.clipboardData?.getData("text") ?? "";
+		const start = input.selectionStart ?? 0;
+		const end = input.selectionEnd ?? 0;
+		const processed = processedRef.current;
+		const { slots, slotChar, transform } = getResolvedOptions(opts, "");
+		const clampedStart = Math.min(start, processed.length);
+		const clampedEnd = Math.min(end, processed.length);
+		const beforeRaw = extractRaw(processed.slice(0, clampedStart), slots.slice(0, clampedStart));
+		const afterRaw = extractRaw(processed.slice(clampedEnd), slots.slice(clampedEnd));
+		const newValue = applyMaskToRaw(beforeRaw + pastedText + afterRaw, slots, slotChar, transform);
+		pushUndoState();
+		updateValue(newValue);
+		const maskedPrefix = applyMaskToRaw(beforeRaw + pastedText, slots, slotChar, transform);
+		const pasteEndPos = Math.min(maskedPrefix.length, slots.length);
+		if (input === document.activeElement) input.setSelectionRange(pasteEndPos, pasteEndPos);
+	}, [pushUndoState, updateValue]);
+	const setAriaAttributes = (0, react.useCallback)((input) => {
+		if (optionsRef.current.invalid) input.setAttribute("aria-invalid", "true");
+		else input.removeAttribute("aria-invalid");
+	}, []);
+	const refCallback = (0, react.useCallback)((node) => {
+		const prevInput = inputRef.current;
+		if (prevInput) {
+			prevInput.removeEventListener("input", handleInput);
+			prevInput.removeEventListener("focus", handleFocus);
+			prevInput.removeEventListener("blur", handleBlur);
+			prevInput.removeEventListener("mousedown", handleMouseDown);
+			prevInput.removeEventListener("mouseup", handleMouseUp);
+			prevInput.removeEventListener("keydown", handleKeyDown);
+			prevInput.removeEventListener("paste", handlePaste);
+		}
+		inputRef.current = node;
+		if (node) {
+			node.addEventListener("input", handleInput);
+			node.addEventListener("focus", handleFocus);
+			node.addEventListener("blur", handleBlur);
+			node.addEventListener("mousedown", handleMouseDown);
+			node.addEventListener("mouseup", handleMouseUp);
+			node.addEventListener("keydown", handleKeyDown);
+			node.addEventListener("paste", handlePaste);
+			setAriaAttributes(node);
+			if (options.alwaysShowMask && !node.value) {
+				const { slots, slotChar } = getResolvedOptions(options, "");
+				const display = buildDisplayValue("", slots, slotChar, true);
+				node.value = display;
+				displayValueRef.current = display;
+				setMaskedValue(display);
+			}
+		}
+	}, [
+		handleInput,
+		handleFocus,
+		handleBlur,
+		handleMouseDown,
+		handleMouseUp,
+		handleKeyDown,
+		handlePaste,
+		setAriaAttributes,
+		options
+	]);
+	(0, react.useEffect)(() => {
+		const input = inputRef.current;
+		if (!input) return;
+		setAriaAttributes(input);
+	}, [options.invalid, setAriaAttributes]);
+	return {
+		ref: refCallback,
+		value: maskedValue,
+		rawValue,
+		isComplete: (() => {
+			const { slots } = getOptions();
+			return checkComplete(processedRef.current, slots);
+		})(),
+		reset: (0, react.useCallback)(() => {
+			const opts = optionsRef.current;
+			const input = inputRef.current;
+			processedRef.current = "";
+			displayValueRef.current = "";
+			rawValueRef.current = "";
+			undoStackRef.current = [];
+			redoStackRef.current = [];
+			setMaskedValue("");
+			setRawValue("");
+			wasCompleteRef.current = false;
+			if (input) if (opts.alwaysShowMask) {
+				const { slots, slotChar } = getResolvedOptions(opts, "");
+				const display = buildDisplayValue("", slots, slotChar, true);
+				input.value = display;
+				displayValueRef.current = display;
+				setMaskedValue(display);
+			} else input.value = "";
+			if (opts.onChangeRaw) opts.onChangeRaw("", "");
+		}, [])
+	};
+}
+function findNextEditablePosition(from, slots, value) {
+	let pos = from;
+	while (pos < slots.length && pos < value.length && slots[pos] && slots[pos].type === "literal") pos++;
+	return pos;
+}
+//#endregion
+exports.formatMask = formatMask;
+exports.generatePattern = generatePattern;
+exports.isMaskComplete = isMaskComplete;
+exports.unformatMask = unformatMask;
+exports.useMask = useMask;
+
+//# sourceMappingURL=use-mask.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-media-query/use-media-query.cjs

@@ -0,0 +1,31 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-media-query/use-media-query.ts
+function getInitialValue(query, initialValue) {
+	if (typeof initialValue === "boolean") return initialValue;
+	if (typeof window !== "undefined" && "matchMedia" in window) return window.matchMedia(query).matches;
+	return false;
+}
+function useMediaQuery(query, initialValue, { getInitialValueInEffect } = { getInitialValueInEffect: true }) {
+	const [matches, setMatches] = (0, react.useState)(getInitialValueInEffect ? initialValue : getInitialValue(query));
+	(0, react.useEffect)(() => {
+		try {
+			if ("matchMedia" in window) {
+				const mediaQuery = window.matchMedia(query);
+				setMatches(mediaQuery.matches);
+				const callback = (event) => setMatches(event.matches);
+				mediaQuery.addEventListener("change", callback);
+				return () => {
+					mediaQuery.removeEventListener("change", callback);
+				};
+			}
+		} catch (e) {
+			return;
+		}
+	}, [query]);
+	return matches || false;
+}
+//#endregion
+exports.useMediaQuery = useMediaQuery;
+
+//# sourceMappingURL=use-media-query.cjs.map

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-media-query/use-media-query.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-query.cjs","names":[],"sources":["../../src/use-media-query/use-media-query.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\nexport interface UseMediaQueryOptions {\n  getInitialValueInEffect: boolean;\n}\n\nfunction getInitialValue(query: string, initialValue?: boolean) {\n  if (typeof initialValue === 'boolean') {\n    return initialValue;\n  }\n\n  if (typeof window !== 'undefined' && 'matchMedia' in window) {\n    return window.matchMedia(query).matches;\n  }\n\n  return false;\n}\n\nexport function useMediaQuery(\n  query: string,\n  initialValue?: boolean,\n  { getInitialValueInEffect }: UseMediaQueryOptions = {\n    getInitialValueInEffect: true,\n  }\n): boolean {\n  const [matches, setMatches] = useState(\n    getInitialValueInEffect ? initialValue : getInitialValue(query)\n  );\n  useEffect(() => {\n    try {\n      if ('matchMedia' in window) {\n        const mediaQuery = window.matchMedia(query);\n        setMatches(mediaQuery.matches);\n        const callback = (event: MediaQueryListEvent) => setMatches(event.matches);\n        mediaQuery.addEventListener('change', callback);\n        return () => {\n          mediaQuery.removeEventListener('change', callback);\n        };\n      }\n    } catch (e) {\n      // Safari iframe compatibility issue\n      return undefined;\n    }\n  }, [query]);\n\n  return matches || false;\n}\n\nexport namespace useMediaQuery {\n  export type Options = UseMediaQueryOptions;\n}\n"],"mappings":";;;AAMA,SAAS,gBAAgB,OAAe,cAAwB;CAC9D,IAAI,OAAO,iBAAiB,WAC1B,OAAO;CAGT,IAAI,OAAO,WAAW,eAAe,gBAAgB,QACnD,OAAO,OAAO,WAAW,KAAK,EAAE;CAGlC,OAAO;AACT;AAEA,SAAgB,cACd,OACA,cACA,EAAE,4BAAkD,EAClD,yBAAyB,KAC3B,GACS;CACT,MAAM,CAAC,SAAS,eAAA,GAAA,MAAA,UACd,0BAA0B,eAAe,gBAAgB,KAAK,CAChE;CACA,CAAA,GAAA,MAAA,iBAAgB;EACd,IAAI;GACF,IAAI,gBAAgB,QAAQ;IAC1B,MAAM,aAAa,OAAO,WAAW,KAAK;IAC1C,WAAW,WAAW,OAAO;IAC7B,MAAM,YAAY,UAA+B,WAAW,MAAM,OAAO;IACzE,WAAW,iBAAiB,UAAU,QAAQ;IAC9C,aAAa;KACX,WAAW,oBAAoB,UAAU,QAAQ;IACnD;GACF;EACF,SAAS,GAAG;GAEV;EACF;CACF,GAAG,CAAC,KAAK,CAAC;CAEV,OAAO,WAAW;AACpB"}

web/node_modules/.pnpm/@mantine+hooks@9.3.0_react@19.2.7/node_modules/@mantine/hooks/cjs/use-merged-ref/use-merged-ref.cjs

@@ -0,0 +1,33 @@
+"use client";
+let react = require("react");
+//#region packages/@mantine/hooks/src/use-merged-ref/use-merged-ref.ts
+function assignRef(ref, value) {
+	if (typeof ref === "function") return ref(value);
+	else if (typeof ref === "object" && ref !== null && "current" in ref) ref.current = value;
+}
+function mergeRefs(...refs) {
+	const cleanupMap = /* @__PURE__ */ new Map();
+	return (node) => {
+		refs.forEach((ref) => {
+			const cleanup = assignRef(ref, node);
+			if (cleanup) cleanupMap.set(ref, cleanup);
+		});
+		if (cleanupMap.size > 0) return () => {
+			refs.forEach((ref) => {
+				const cleanup = cleanupMap.get(ref);
+				if (cleanup && typeof cleanup === "function") cleanup();
+				else assignRef(ref, null);
+			});
+			cleanupMap.clear();
+		};
+	};
+}
+function useMergedRef(...refs) {
+	return (0, react.useCallback)(mergeRefs(...refs), refs);
+}
+//#endregion
+exports.assignRef = assignRef;
+exports.mergeRefs = mergeRefs;
+exports.useMergedRef = useMergedRef;
+
+//# sourceMappingURL=use-merged-ref.cjs.map