@norskvideo/norsk-studio-built-ins 1.27.0-2025-05-21-b03b48ea → 1.27.0-2025-05-22-5168ed86

package/client/info.js

@@ -22831,9 +22831,9 @@ var require_lucide_react = __commonJS({
   }
 });
 
-// ../core/node_modules/tailwind-merge/dist/bundle-cjs.js
+// ../../node_modules/tailwind-merge/dist/bundle-cjs.js
 var require_bundle_cjs = __commonJS({
-  "../core/node_modules/tailwind-merge/dist/bundle-cjs.js"(exports) {
+  "../../node_modules/tailwind-merge/dist/bundle-cjs.js"(exports) {
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, {
       value: "Module"
@@ -57737,6 +57737,2276 @@ var require_dist44 = __commonJS({
   }
 });
 
+// ../core/node_modules/@radix-ui/primitive/dist/index.js
+var require_dist45 = __commonJS({
+  "../core/node_modules/@radix-ui/primitive/dist/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      composeEventHandlers: () => composeEventHandlers
+    });
+    module.exports = __toCommonJS2(index_exports);
+    function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+      return function handleEvent(event) {
+        originalEventHandler?.(event);
+        if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+          return ourEventHandler?.(event);
+        }
+      };
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-compose-refs/dist/index.js
+var require_dist46 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-compose-refs/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      composeRefs: () => composeRefs,
+      useComposedRefs: () => useComposedRefs
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    function setRef(ref, value) {
+      if (typeof ref === "function") {
+        return ref(value);
+      } else if (ref !== null && ref !== void 0) {
+        ref.current = value;
+      }
+    }
+    function composeRefs(...refs) {
+      return (node) => {
+        let hasCleanup = false;
+        const cleanups = refs.map((ref) => {
+          const cleanup = setRef(ref, node);
+          if (!hasCleanup && typeof cleanup == "function") {
+            hasCleanup = true;
+          }
+          return cleanup;
+        });
+        if (hasCleanup) {
+          return () => {
+            for (let i = 0; i < cleanups.length; i++) {
+              const cleanup = cleanups[i];
+              if (typeof cleanup == "function") {
+                cleanup();
+              } else {
+                setRef(refs[i], null);
+              }
+            }
+          };
+        }
+      };
+    }
+    function useComposedRefs(...refs) {
+      return React3.useCallback(composeRefs(...refs), refs);
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-context/dist/index.js
+var require_dist47 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-context/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      createContext: () => createContext2,
+      createContextScope: () => createContextScope
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_jsx_runtime44 = require_jsx_runtime();
+    function createContext2(rootComponentName, defaultContext) {
+      const Context = React3.createContext(defaultContext);
+      const Provider = (props) => {
+        const { children, ...context } = props;
+        const value = React3.useMemo(() => context, Object.values(context));
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(Context.Provider, { value, children });
+      };
+      Provider.displayName = rootComponentName + "Provider";
+      function useContext2(consumerName) {
+        const context = React3.useContext(Context);
+        if (context)
+          return context;
+        if (defaultContext !== void 0)
+          return defaultContext;
+        throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+      }
+      return [Provider, useContext2];
+    }
+    function createContextScope(scopeName, createContextScopeDeps = []) {
+      let defaultContexts = [];
+      function createContext3(rootComponentName, defaultContext) {
+        const BaseContext = React3.createContext(defaultContext);
+        const index3 = defaultContexts.length;
+        defaultContexts = [...defaultContexts, defaultContext];
+        const Provider = (props) => {
+          const { scope, children, ...context } = props;
+          const Context = scope?.[scopeName]?.[index3] || BaseContext;
+          const value = React3.useMemo(() => context, Object.values(context));
+          return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(Context.Provider, { value, children });
+        };
+        Provider.displayName = rootComponentName + "Provider";
+        function useContext2(consumerName, scope) {
+          const Context = scope?.[scopeName]?.[index3] || BaseContext;
+          const context = React3.useContext(Context);
+          if (context)
+            return context;
+          if (defaultContext !== void 0)
+            return defaultContext;
+          throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+        }
+        return [Provider, useContext2];
+      }
+      const createScope = () => {
+        const scopeContexts = defaultContexts.map((defaultContext) => {
+          return React3.createContext(defaultContext);
+        });
+        return function useScope(scope) {
+          const contexts = scope?.[scopeName] || scopeContexts;
+          return React3.useMemo(
+            () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
+            [scope, contexts]
+          );
+        };
+      };
+      createScope.scopeName = scopeName;
+      return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
+    }
+    function composeContextScopes(...scopes) {
+      const baseScope = scopes[0];
+      if (scopes.length === 1)
+        return baseScope;
+      const createScope = () => {
+        const scopeHooks = scopes.map((createScope2) => ({
+          useScope: createScope2(),
+          scopeName: createScope2.scopeName
+        }));
+        return function useComposedScopes(overrideScopes) {
+          const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
+            const scopeProps = useScope(overrideScopes);
+            const currentScope = scopeProps[`__scope${scopeName}`];
+            return { ...nextScopes2, ...currentScope };
+          }, {});
+          return React3.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+        };
+      };
+      createScope.scopeName = baseScope.scopeName;
+      return createScope;
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-id/node_modules/@radix-ui/react-use-layout-effect/dist/index.js
+var require_dist48 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-id/node_modules/@radix-ui/react-use-layout-effect/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useLayoutEffect: () => useLayoutEffect2
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var useLayoutEffect2 = globalThis?.document ? React3.useLayoutEffect : () => {
+    };
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-id/dist/index.js
+var require_dist49 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-id/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useId: () => useId
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_react_use_layout_effect = require_dist48();
+    var useReactId = React3[" useId ".trim().toString()] || (() => void 0);
+    var count = 0;
+    function useId(deterministicId) {
+      const [id, setId] = React3.useState(useReactId());
+      (0, import_react_use_layout_effect.useLayoutEffect)(() => {
+        if (!deterministicId)
+          setId((reactId) => reactId ?? String(count++));
+      }, [deterministicId]);
+      return deterministicId || (id ? `radix-${id}` : "");
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-use-controllable-state/node_modules/@radix-ui/react-use-layout-effect/dist/index.js
+var require_dist50 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-use-controllable-state/node_modules/@radix-ui/react-use-layout-effect/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useLayoutEffect: () => useLayoutEffect2
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var useLayoutEffect2 = globalThis?.document ? React3.useLayoutEffect : () => {
+    };
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-use-controllable-state/dist/index.js
+var require_dist51 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-use-controllable-state/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useControllableState: () => useControllableState,
+      useControllableStateReducer: () => useControllableStateReducer
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_react_use_layout_effect = require_dist50();
+    var useInsertionEffect = React3[" useInsertionEffect ".trim().toString()] || import_react_use_layout_effect.useLayoutEffect;
+    function useControllableState({
+      prop,
+      defaultProp,
+      onChange = () => {
+      },
+      caller
+    }) {
+      const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
+        defaultProp,
+        onChange
+      });
+      const isControlled = prop !== void 0;
+      const value = isControlled ? prop : uncontrolledProp;
+      if (true) {
+        const isControlledRef = React3.useRef(prop !== void 0);
+        React3.useEffect(() => {
+          const wasControlled = isControlledRef.current;
+          if (wasControlled !== isControlled) {
+            const from2 = wasControlled ? "controlled" : "uncontrolled";
+            const to2 = isControlled ? "controlled" : "uncontrolled";
+            console.warn(
+              `${caller} is changing from ${from2} to ${to2}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+            );
+          }
+          isControlledRef.current = isControlled;
+        }, [isControlled, caller]);
+      }
+      const setValue = React3.useCallback(
+        (nextValue) => {
+          if (isControlled) {
+            const value2 = isFunction2(nextValue) ? nextValue(prop) : nextValue;
+            if (value2 !== prop) {
+              onChangeRef.current?.(value2);
+            }
+          } else {
+            setUncontrolledProp(nextValue);
+          }
+        },
+        [isControlled, prop, setUncontrolledProp, onChangeRef]
+      );
+      return [value, setValue];
+    }
+    function useUncontrolledState({
+      defaultProp,
+      onChange
+    }) {
+      const [value, setValue] = React3.useState(defaultProp);
+      const prevValueRef = React3.useRef(value);
+      const onChangeRef = React3.useRef(onChange);
+      useInsertionEffect(() => {
+        onChangeRef.current = onChange;
+      }, [onChange]);
+      React3.useEffect(() => {
+        if (prevValueRef.current !== value) {
+          onChangeRef.current?.(value);
+          prevValueRef.current = value;
+        }
+      }, [value, prevValueRef]);
+      return [value, setValue, onChangeRef];
+    }
+    function isFunction2(value) {
+      return typeof value === "function";
+    }
+    var React22 = __toESM2(require_react());
+    var import_react_use_effect_event = require_dist32();
+    var SYNC_STATE = Symbol("RADIX:SYNC_STATE");
+    function useControllableStateReducer(reducer, userArgs, initialArg, init) {
+      const { prop: controlledState, defaultProp, onChange: onChangeProp, caller } = userArgs;
+      const isControlled = controlledState !== void 0;
+      const onChange = (0, import_react_use_effect_event.useEffectEvent)(onChangeProp);
+      if (true) {
+        const isControlledRef = React22.useRef(controlledState !== void 0);
+        React22.useEffect(() => {
+          const wasControlled = isControlledRef.current;
+          if (wasControlled !== isControlled) {
+            const from2 = wasControlled ? "controlled" : "uncontrolled";
+            const to2 = isControlled ? "controlled" : "uncontrolled";
+            console.warn(
+              `${caller} is changing from ${from2} to ${to2}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+            );
+          }
+          isControlledRef.current = isControlled;
+        }, [isControlled, caller]);
+      }
+      const args = [{ ...initialArg, state: defaultProp }];
+      if (init) {
+        args.push(init);
+      }
+      const [internalState, dispatch] = React22.useReducer(
+        (state2, action) => {
+          if (action.type === SYNC_STATE) {
+            return { ...state2, state: action.state };
+          }
+          const next = reducer(state2, action);
+          if (isControlled && !Object.is(next.state, state2.state)) {
+            onChange(next.state);
+          }
+          return next;
+        },
+        ...args
+      );
+      const uncontrolledState = internalState.state;
+      const prevValueRef = React22.useRef(uncontrolledState);
+      React22.useEffect(() => {
+        if (prevValueRef.current !== uncontrolledState) {
+          prevValueRef.current = uncontrolledState;
+          if (!isControlled) {
+            onChange(uncontrolledState);
+          }
+        }
+      }, [onChange, uncontrolledState, prevValueRef, isControlled]);
+      const state = React22.useMemo(() => {
+        const isControlled2 = controlledState !== void 0;
+        if (isControlled2) {
+          return { ...internalState, state: controlledState };
+        }
+        return internalState;
+      }, [internalState, controlledState]);
+      React22.useEffect(() => {
+        if (isControlled && !Object.is(controlledState, internalState.state)) {
+          dispatch({ type: SYNC_STATE, state: controlledState });
+        }
+      }, [controlledState, internalState.state, isControlled]);
+      return [state, dispatch];
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-slot/node_modules/@radix-ui/react-compose-refs/dist/index.js
+var require_dist52 = __commonJS({
+  "../core/node_modules/@radix-ui/react-slot/node_modules/@radix-ui/react-compose-refs/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      composeRefs: () => composeRefs,
+      useComposedRefs: () => useComposedRefs
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    function setRef(ref, value) {
+      if (typeof ref === "function") {
+        return ref(value);
+      } else if (ref !== null && ref !== void 0) {
+        ref.current = value;
+      }
+    }
+    function composeRefs(...refs) {
+      return (node) => {
+        let hasCleanup = false;
+        const cleanups = refs.map((ref) => {
+          const cleanup = setRef(ref, node);
+          if (!hasCleanup && typeof cleanup == "function") {
+            hasCleanup = true;
+          }
+          return cleanup;
+        });
+        if (hasCleanup) {
+          return () => {
+            for (let i = 0; i < cleanups.length; i++) {
+              const cleanup = cleanups[i];
+              if (typeof cleanup == "function") {
+                cleanup();
+              } else {
+                setRef(refs[i], null);
+              }
+            }
+          };
+        }
+      };
+    }
+    function useComposedRefs(...refs) {
+      return React3.useCallback(composeRefs(...refs), refs);
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-slot/dist/index.js
+var require_dist53 = __commonJS({
+  "../core/node_modules/@radix-ui/react-slot/dist/index.js"(exports, module) {
+    "use strict";
+    "use client";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      Root: () => Slot,
+      Slot: () => Slot,
+      Slottable: () => Slottable,
+      createSlot: () => createSlot,
+      createSlottable: () => createSlottable
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_react_compose_refs = require_dist52();
+    var import_jsx_runtime44 = require_jsx_runtime();
+    // @__NO_SIDE_EFFECTS__
+    function createSlot(ownerName) {
+      const SlotClone = /* @__PURE__ */ createSlotClone(ownerName);
+      const Slot2 = React3.forwardRef((props, forwardedRef) => {
+        const { children, ...slotProps } = props;
+        const childrenArray = React3.Children.toArray(children);
+        const slottable = childrenArray.find(isSlottable);
+        if (slottable) {
+          const newElement = slottable.props.children;
+          const newChildren = childrenArray.map((child) => {
+            if (child === slottable) {
+              if (React3.Children.count(newElement) > 1)
+                return React3.Children.only(null);
+              return React3.isValidElement(newElement) ? newElement.props.children : null;
+            } else {
+              return child;
+            }
+          });
+          return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children: React3.isValidElement(newElement) ? React3.cloneElement(newElement, void 0, newChildren) : null });
+        }
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children });
+      });
+      Slot2.displayName = `${ownerName}.Slot`;
+      return Slot2;
+    }
+    var Slot = /* @__PURE__ */ createSlot("Slot");
+    // @__NO_SIDE_EFFECTS__
+    function createSlotClone(ownerName) {
+      const SlotClone = React3.forwardRef((props, forwardedRef) => {
+        const { children, ...slotProps } = props;
+        const childrenRef = React3.isValidElement(children) ? getElementRef(children) : void 0;
+        const ref = (0, import_react_compose_refs.useComposedRefs)(childrenRef, forwardedRef);
+        if (React3.isValidElement(children)) {
+          const props2 = mergeProps(slotProps, children.props);
+          if (children.type !== React3.Fragment) {
+            props2.ref = ref;
+          }
+          return React3.cloneElement(children, props2);
+        }
+        return React3.Children.count(children) > 1 ? React3.Children.only(null) : null;
+      });
+      SlotClone.displayName = `${ownerName}.SlotClone`;
+      return SlotClone;
+    }
+    var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable");
+    // @__NO_SIDE_EFFECTS__
+    function createSlottable(ownerName) {
+      const Slottable2 = ({ children }) => {
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_jsx_runtime44.Fragment, { children });
+      };
+      Slottable2.displayName = `${ownerName}.Slottable`;
+      Slottable2.__radixId = SLOTTABLE_IDENTIFIER;
+      return Slottable2;
+    }
+    var Slottable = /* @__PURE__ */ createSlottable("Slottable");
+    function isSlottable(child) {
+      return React3.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
+    }
+    function mergeProps(slotProps, childProps) {
+      const overrideProps = { ...childProps };
+      for (const propName in childProps) {
+        const slotPropValue = slotProps[propName];
+        const childPropValue = childProps[propName];
+        const isHandler = /^on[A-Z]/.test(propName);
+        if (isHandler) {
+          if (slotPropValue && childPropValue) {
+            overrideProps[propName] = (...args) => {
+              const result2 = childPropValue(...args);
+              slotPropValue(...args);
+              return result2;
+            };
+          } else if (slotPropValue) {
+            overrideProps[propName] = slotPropValue;
+          }
+        } else if (propName === "style") {
+          overrideProps[propName] = { ...slotPropValue, ...childPropValue };
+        } else if (propName === "className") {
+          overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+        }
+      }
+      return { ...slotProps, ...overrideProps };
+    }
+    function getElementRef(element) {
+      let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+      let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+      if (mayWarn) {
+        return element.ref;
+      }
+      getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+      mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+      if (mayWarn) {
+        return element.props.ref;
+      }
+      return element.props.ref || element.ref;
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-primitive/dist/index.js
+var require_dist54 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-primitive/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      Primitive: () => Primitive,
+      Root: () => Root,
+      dispatchDiscreteCustomEvent: () => dispatchDiscreteCustomEvent
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var ReactDOM2 = __toESM2(require_react_dom());
+    var import_react_slot = require_dist53();
+    var import_jsx_runtime44 = require_jsx_runtime();
+    var NODES = [
+      "a",
+      "button",
+      "div",
+      "form",
+      "h2",
+      "h3",
+      "img",
+      "input",
+      "label",
+      "li",
+      "nav",
+      "ol",
+      "p",
+      "select",
+      "span",
+      "svg",
+      "ul"
+    ];
+    var Primitive = NODES.reduce((primitive, node) => {
+      const Slot = (0, import_react_slot.createSlot)(`Primitive.${node}`);
+      const Node2 = React3.forwardRef((props, forwardedRef) => {
+        const { asChild, ...primitiveProps } = props;
+        const Comp = asChild ? Slot : node;
+        if (typeof window !== "undefined") {
+          window[Symbol.for("radix-ui")] = true;
+        }
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(Comp, { ...primitiveProps, ref: forwardedRef });
+      });
+      Node2.displayName = `Primitive.${node}`;
+      return { ...primitive, [node]: Node2 };
+    }, {});
+    function dispatchDiscreteCustomEvent(target, event) {
+      if (target)
+        ReactDOM2.flushSync(() => target.dispatchEvent(event));
+    }
+    var Root = Primitive;
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-dismissable-layer/node_modules/@radix-ui/react-use-callback-ref/dist/index.js
+var require_dist55 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-dismissable-layer/node_modules/@radix-ui/react-use-callback-ref/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useCallbackRef: () => useCallbackRef
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    function useCallbackRef(callback2) {
+      const callbackRef = React3.useRef(callback2);
+      React3.useEffect(() => {
+        callbackRef.current = callback2;
+      });
+      return React3.useMemo(() => (...args) => callbackRef.current?.(...args), []);
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-dismissable-layer/node_modules/@radix-ui/react-use-escape-keydown/dist/index.js
+var require_dist56 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-dismissable-layer/node_modules/@radix-ui/react-use-escape-keydown/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useEscapeKeydown: () => useEscapeKeydown
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_react_use_callback_ref = require_dist55();
+    function useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {
+      const onEscapeKeyDown = (0, import_react_use_callback_ref.useCallbackRef)(onEscapeKeyDownProp);
+      React3.useEffect(() => {
+        const handleKeyDown = (event) => {
+          if (event.key === "Escape") {
+            onEscapeKeyDown(event);
+          }
+        };
+        ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
+        return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
+      }, [onEscapeKeyDown, ownerDocument]);
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-dismissable-layer/dist/index.js
+var require_dist57 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-dismissable-layer/dist/index.js"(exports, module) {
+    "use strict";
+    "use client";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      Branch: () => Branch,
+      DismissableLayer: () => DismissableLayer,
+      DismissableLayerBranch: () => DismissableLayerBranch,
+      Root: () => Root
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_primitive = require_dist45();
+    var import_react_primitive = require_dist54();
+    var import_react_compose_refs = require_dist46();
+    var import_react_use_callback_ref = require_dist55();
+    var import_react_use_escape_keydown = require_dist56();
+    var import_jsx_runtime44 = require_jsx_runtime();
+    var DISMISSABLE_LAYER_NAME = "DismissableLayer";
+    var CONTEXT_UPDATE = "dismissableLayer.update";
+    var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
+    var FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
+    var originalBodyPointerEvents;
+    var DismissableLayerContext = React3.createContext({
+      layers: /* @__PURE__ */ new Set(),
+      layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+      branches: /* @__PURE__ */ new Set()
+    });
+    var DismissableLayer = React3.forwardRef(
+      (props, forwardedRef) => {
+        const {
+          disableOutsidePointerEvents = false,
+          onEscapeKeyDown,
+          onPointerDownOutside,
+          onFocusOutside,
+          onInteractOutside,
+          onDismiss,
+          ...layerProps
+        } = props;
+        const context = React3.useContext(DismissableLayerContext);
+        const [node, setNode] = React3.useState(null);
+        const ownerDocument = node?.ownerDocument ?? globalThis?.document;
+        const [, force] = React3.useState({});
+        const composedRefs = (0, import_react_compose_refs.useComposedRefs)(forwardedRef, (node2) => setNode(node2));
+        const layers = Array.from(context.layers);
+        const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
+        const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled);
+        const index3 = node ? layers.indexOf(node) : -1;
+        const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;
+        const isPointerEventsEnabled = index3 >= highestLayerWithOutsidePointerEventsDisabledIndex;
+        const pointerDownOutside = usePointerDownOutside((event) => {
+          const target = event.target;
+          const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));
+          if (!isPointerEventsEnabled || isPointerDownOnBranch)
+            return;
+          onPointerDownOutside?.(event);
+          onInteractOutside?.(event);
+          if (!event.defaultPrevented)
+            onDismiss?.();
+        }, ownerDocument);
+        const focusOutside = useFocusOutside((event) => {
+          const target = event.target;
+          const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target));
+          if (isFocusInBranch)
+            return;
+          onFocusOutside?.(event);
+          onInteractOutside?.(event);
+          if (!event.defaultPrevented)
+            onDismiss?.();
+        }, ownerDocument);
+        (0, import_react_use_escape_keydown.useEscapeKeydown)((event) => {
+          const isHighestLayer = index3 === context.layers.size - 1;
+          if (!isHighestLayer)
+            return;
+          onEscapeKeyDown?.(event);
+          if (!event.defaultPrevented && onDismiss) {
+            event.preventDefault();
+            onDismiss();
+          }
+        }, ownerDocument);
+        React3.useEffect(() => {
+          if (!node)
+            return;
+          if (disableOutsidePointerEvents) {
+            if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
+              originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
+              ownerDocument.body.style.pointerEvents = "none";
+            }
+            context.layersWithOutsidePointerEventsDisabled.add(node);
+          }
+          context.layers.add(node);
+          dispatchUpdate();
+          return () => {
+            if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) {
+              ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
+            }
+          };
+        }, [node, ownerDocument, disableOutsidePointerEvents, context]);
+        React3.useEffect(() => {
+          return () => {
+            if (!node)
+              return;
+            context.layers.delete(node);
+            context.layersWithOutsidePointerEventsDisabled.delete(node);
+            dispatchUpdate();
+          };
+        }, [node, context]);
+        React3.useEffect(() => {
+          const handleUpdate = () => force({});
+          document.addEventListener(CONTEXT_UPDATE, handleUpdate);
+          return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
+        }, []);
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+          import_react_primitive.Primitive.div,
+          {
+            ...layerProps,
+            ref: composedRefs,
+            style: {
+              pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0,
+              ...props.style
+            },
+            onFocusCapture: (0, import_primitive.composeEventHandlers)(props.onFocusCapture, focusOutside.onFocusCapture),
+            onBlurCapture: (0, import_primitive.composeEventHandlers)(props.onBlurCapture, focusOutside.onBlurCapture),
+            onPointerDownCapture: (0, import_primitive.composeEventHandlers)(
+              props.onPointerDownCapture,
+              pointerDownOutside.onPointerDownCapture
+            )
+          }
+        );
+      }
+    );
+    DismissableLayer.displayName = DISMISSABLE_LAYER_NAME;
+    var BRANCH_NAME = "DismissableLayerBranch";
+    var DismissableLayerBranch = React3.forwardRef((props, forwardedRef) => {
+      const context = React3.useContext(DismissableLayerContext);
+      const ref = React3.useRef(null);
+      const composedRefs = (0, import_react_compose_refs.useComposedRefs)(forwardedRef, ref);
+      React3.useEffect(() => {
+        const node = ref.current;
+        if (node) {
+          context.branches.add(node);
+          return () => {
+            context.branches.delete(node);
+          };
+        }
+      }, [context.branches]);
+      return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_primitive.Primitive.div, { ...props, ref: composedRefs });
+    });
+    DismissableLayerBranch.displayName = BRANCH_NAME;
+    function usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis?.document) {
+      const handlePointerDownOutside = (0, import_react_use_callback_ref.useCallbackRef)(onPointerDownOutside);
+      const isPointerInsideReactTreeRef = React3.useRef(false);
+      const handleClickRef = React3.useRef(() => {
+      });
+      React3.useEffect(() => {
+        const handlePointerDown = (event) => {
+          if (event.target && !isPointerInsideReactTreeRef.current) {
+            let handleAndDispatchPointerDownOutsideEvent2 = function() {
+              handleAndDispatchCustomEvent(
+                POINTER_DOWN_OUTSIDE,
+                handlePointerDownOutside,
+                eventDetail,
+                { discrete: true }
+              );
+            };
+            var handleAndDispatchPointerDownOutsideEvent = handleAndDispatchPointerDownOutsideEvent2;
+            const eventDetail = { originalEvent: event };
+            if (event.pointerType === "touch") {
+              ownerDocument.removeEventListener("click", handleClickRef.current);
+              handleClickRef.current = handleAndDispatchPointerDownOutsideEvent2;
+              ownerDocument.addEventListener("click", handleClickRef.current, { once: true });
+            } else {
+              handleAndDispatchPointerDownOutsideEvent2();
+            }
+          } else {
+            ownerDocument.removeEventListener("click", handleClickRef.current);
+          }
+          isPointerInsideReactTreeRef.current = false;
+        };
+        const timerId = window.setTimeout(() => {
+          ownerDocument.addEventListener("pointerdown", handlePointerDown);
+        }, 0);
+        return () => {
+          window.clearTimeout(timerId);
+          ownerDocument.removeEventListener("pointerdown", handlePointerDown);
+          ownerDocument.removeEventListener("click", handleClickRef.current);
+        };
+      }, [ownerDocument, handlePointerDownOutside]);
+      return {
+        // ensures we check React component tree (not just DOM tree)
+        onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true
+      };
+    }
+    function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
+      const handleFocusOutside = (0, import_react_use_callback_ref.useCallbackRef)(onFocusOutside);
+      const isFocusInsideReactTreeRef = React3.useRef(false);
+      React3.useEffect(() => {
+        const handleFocus = (event) => {
+          if (event.target && !isFocusInsideReactTreeRef.current) {
+            const eventDetail = { originalEvent: event };
+            handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {
+              discrete: false
+            });
+          }
+        };
+        ownerDocument.addEventListener("focusin", handleFocus);
+        return () => ownerDocument.removeEventListener("focusin", handleFocus);
+      }, [ownerDocument, handleFocusOutside]);
+      return {
+        onFocusCapture: () => isFocusInsideReactTreeRef.current = true,
+        onBlurCapture: () => isFocusInsideReactTreeRef.current = false
+      };
+    }
+    function dispatchUpdate() {
+      const event = new CustomEvent(CONTEXT_UPDATE);
+      document.dispatchEvent(event);
+    }
+    function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
+      const target = detail.originalEvent.target;
+      const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });
+      if (handler)
+        target.addEventListener(name, handler, { once: true });
+      if (discrete) {
+        (0, import_react_primitive.dispatchDiscreteCustomEvent)(target, event);
+      } else {
+        target.dispatchEvent(event);
+      }
+    }
+    var Root = DismissableLayer;
+    var Branch = DismissableLayerBranch;
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-focus-scope/node_modules/@radix-ui/react-use-callback-ref/dist/index.js
+var require_dist58 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-focus-scope/node_modules/@radix-ui/react-use-callback-ref/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useCallbackRef: () => useCallbackRef
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    function useCallbackRef(callback2) {
+      const callbackRef = React3.useRef(callback2);
+      React3.useEffect(() => {
+        callbackRef.current = callback2;
+      });
+      return React3.useMemo(() => (...args) => callbackRef.current?.(...args), []);
+    }
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-focus-scope/dist/index.js
+var require_dist59 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-focus-scope/dist/index.js"(exports, module) {
+    "use strict";
+    "use client";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      FocusScope: () => FocusScope,
+      Root: () => Root
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_react_compose_refs = require_dist46();
+    var import_react_primitive = require_dist54();
+    var import_react_use_callback_ref = require_dist58();
+    var import_jsx_runtime44 = require_jsx_runtime();
+    var AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
+    var AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
+    var EVENT_OPTIONS = { bubbles: false, cancelable: true };
+    var FOCUS_SCOPE_NAME = "FocusScope";
+    var FocusScope = React3.forwardRef((props, forwardedRef) => {
+      const {
+        loop = false,
+        trapped = false,
+        onMountAutoFocus: onMountAutoFocusProp,
+        onUnmountAutoFocus: onUnmountAutoFocusProp,
+        ...scopeProps
+      } = props;
+      const [container, setContainer] = React3.useState(null);
+      const onMountAutoFocus = (0, import_react_use_callback_ref.useCallbackRef)(onMountAutoFocusProp);
+      const onUnmountAutoFocus = (0, import_react_use_callback_ref.useCallbackRef)(onUnmountAutoFocusProp);
+      const lastFocusedElementRef = React3.useRef(null);
+      const composedRefs = (0, import_react_compose_refs.useComposedRefs)(forwardedRef, (node) => setContainer(node));
+      const focusScope = React3.useRef({
+        paused: false,
+        pause() {
+          this.paused = true;
+        },
+        resume() {
+          this.paused = false;
+        }
+      }).current;
+      React3.useEffect(() => {
+        if (trapped) {
+          let handleFocusIn2 = function(event) {
+            if (focusScope.paused || !container)
+              return;
+            const target = event.target;
+            if (container.contains(target)) {
+              lastFocusedElementRef.current = target;
+            } else {
+              focus(lastFocusedElementRef.current, { select: true });
+            }
+          }, handleFocusOut2 = function(event) {
+            if (focusScope.paused || !container)
+              return;
+            const relatedTarget = event.relatedTarget;
+            if (relatedTarget === null)
+              return;
+            if (!container.contains(relatedTarget)) {
+              focus(lastFocusedElementRef.current, { select: true });
+            }
+          }, handleMutations2 = function(mutations) {
+            const focusedElement = document.activeElement;
+            if (focusedElement !== document.body)
+              return;
+            for (const mutation of mutations) {
+              if (mutation.removedNodes.length > 0)
+                focus(container);
+            }
+          };
+          var handleFocusIn = handleFocusIn2, handleFocusOut = handleFocusOut2, handleMutations = handleMutations2;
+          document.addEventListener("focusin", handleFocusIn2);
+          document.addEventListener("focusout", handleFocusOut2);
+          const mutationObserver = new MutationObserver(handleMutations2);
+          if (container)
+            mutationObserver.observe(container, { childList: true, subtree: true });
+          return () => {
+            document.removeEventListener("focusin", handleFocusIn2);
+            document.removeEventListener("focusout", handleFocusOut2);
+            mutationObserver.disconnect();
+          };
+        }
+      }, [trapped, container, focusScope.paused]);
+      React3.useEffect(() => {
+        if (container) {
+          focusScopesStack.add(focusScope);
+          const previouslyFocusedElement = document.activeElement;
+          const hasFocusedCandidate = container.contains(previouslyFocusedElement);
+          if (!hasFocusedCandidate) {
+            const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
+            container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+            container.dispatchEvent(mountEvent);
+            if (!mountEvent.defaultPrevented) {
+              focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
+              if (document.activeElement === previouslyFocusedElement) {
+                focus(container);
+              }
+            }
+          }
+          return () => {
+            container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+            setTimeout(() => {
+              const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
+              container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+              container.dispatchEvent(unmountEvent);
+              if (!unmountEvent.defaultPrevented) {
+                focus(previouslyFocusedElement ?? document.body, { select: true });
+              }
+              container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+              focusScopesStack.remove(focusScope);
+            }, 0);
+          };
+        }
+      }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);
+      const handleKeyDown = React3.useCallback(
+        (event) => {
+          if (!loop && !trapped)
+            return;
+          if (focusScope.paused)
+            return;
+          const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+          const focusedElement = document.activeElement;
+          if (isTabKey && focusedElement) {
+            const container2 = event.currentTarget;
+            const [first, last] = getTabbableEdges(container2);
+            const hasTabbableElementsInside = first && last;
+            if (!hasTabbableElementsInside) {
+              if (focusedElement === container2)
+                event.preventDefault();
+            } else {
+              if (!event.shiftKey && focusedElement === last) {
+                event.preventDefault();
+                if (loop)
+                  focus(first, { select: true });
+              } else if (event.shiftKey && focusedElement === first) {
+                event.preventDefault();
+                if (loop)
+                  focus(last, { select: true });
+              }
+            }
+          }
+        },
+        [loop, trapped, focusScope.paused]
+      );
+      return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_primitive.Primitive.div, { tabIndex: -1, ...scopeProps, ref: composedRefs, onKeyDown: handleKeyDown });
+    });
+    FocusScope.displayName = FOCUS_SCOPE_NAME;
+    function focusFirst(candidates, { select = false } = {}) {
+      const previouslyFocusedElement = document.activeElement;
+      for (const candidate of candidates) {
+        focus(candidate, { select });
+        if (document.activeElement !== previouslyFocusedElement)
+          return;
+      }
+    }
+    function getTabbableEdges(container) {
+      const candidates = getTabbableCandidates(container);
+      const first = findVisible(candidates, container);
+      const last = findVisible(candidates.reverse(), container);
+      return [first, last];
+    }
+    function getTabbableCandidates(container) {
+      const nodes = [];
+      const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+        acceptNode: (node) => {
+          const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+          if (node.disabled || node.hidden || isHiddenInput)
+            return NodeFilter.FILTER_SKIP;
+          return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+        }
+      });
+      while (walker.nextNode())
+        nodes.push(walker.currentNode);
+      return nodes;
+    }
+    function findVisible(elements2, container) {
+      for (const element of elements2) {
+        if (!isHidden(element, { upTo: container }))
+          return element;
+      }
+    }
+    function isHidden(node, { upTo }) {
+      if (getComputedStyle(node).visibility === "hidden")
+        return true;
+      while (node) {
+        if (upTo !== void 0 && node === upTo)
+          return false;
+        if (getComputedStyle(node).display === "none")
+          return true;
+        node = node.parentElement;
+      }
+      return false;
+    }
+    function isSelectableInput(element) {
+      return element instanceof HTMLInputElement && "select" in element;
+    }
+    function focus(element, { select = false } = {}) {
+      if (element && element.focus) {
+        const previouslyFocusedElement = document.activeElement;
+        element.focus({ preventScroll: true });
+        if (element !== previouslyFocusedElement && isSelectableInput(element) && select)
+          element.select();
+      }
+    }
+    var focusScopesStack = createFocusScopesStack();
+    function createFocusScopesStack() {
+      let stack = [];
+      return {
+        add(focusScope) {
+          const activeFocusScope = stack[0];
+          if (focusScope !== activeFocusScope) {
+            activeFocusScope?.pause();
+          }
+          stack = arrayRemove(stack, focusScope);
+          stack.unshift(focusScope);
+        },
+        remove(focusScope) {
+          stack = arrayRemove(stack, focusScope);
+          stack[0]?.resume();
+        }
+      };
+    }
+    function arrayRemove(array, item) {
+      const updatedArray = [...array];
+      const index3 = updatedArray.indexOf(item);
+      if (index3 !== -1) {
+        updatedArray.splice(index3, 1);
+      }
+      return updatedArray;
+    }
+    function removeLinks(items) {
+      return items.filter((item) => item.tagName !== "A");
+    }
+    var Root = FocusScope;
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-portal/node_modules/@radix-ui/react-use-layout-effect/dist/index.js
+var require_dist60 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-portal/node_modules/@radix-ui/react-use-layout-effect/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useLayoutEffect: () => useLayoutEffect2
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var useLayoutEffect2 = globalThis?.document ? React3.useLayoutEffect : () => {
+    };
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-portal/dist/index.js
+var require_dist61 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-portal/dist/index.js"(exports, module) {
+    "use strict";
+    "use client";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      Portal: () => Portal,
+      Root: () => Root
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_react_dom = __toESM2(require_react_dom());
+    var import_react_primitive = require_dist54();
+    var import_react_use_layout_effect = require_dist60();
+    var import_jsx_runtime44 = require_jsx_runtime();
+    var PORTAL_NAME = "Portal";
+    var Portal = React3.forwardRef((props, forwardedRef) => {
+      const { container: containerProp, ...portalProps } = props;
+      const [mounted, setMounted] = React3.useState(false);
+      (0, import_react_use_layout_effect.useLayoutEffect)(() => setMounted(true), []);
+      const container = containerProp || mounted && globalThis?.document?.body;
+      return container ? import_react_dom.default.createPortal(/* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_primitive.Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null;
+    });
+    Portal.displayName = PORTAL_NAME;
+    var Root = Portal;
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-presence/node_modules/@radix-ui/react-use-layout-effect/dist/index.js
+var require_dist62 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-presence/node_modules/@radix-ui/react-use-layout-effect/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      useLayoutEffect: () => useLayoutEffect2
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var useLayoutEffect2 = globalThis?.document ? React3.useLayoutEffect : () => {
+    };
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-presence/dist/index.js
+var require_dist63 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-presence/dist/index.js"(exports, module) {
+    "use strict";
+    "use client";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      Presence: () => Presence,
+      Root: () => Root
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React22 = __toESM2(require_react());
+    var import_react_compose_refs = require_dist46();
+    var import_react_use_layout_effect = require_dist62();
+    var React3 = __toESM2(require_react());
+    function useStateMachine(initialState, machine) {
+      return React3.useReducer((state, event) => {
+        const nextState = machine[state][event];
+        return nextState ?? state;
+      }, initialState);
+    }
+    var Presence = (props) => {
+      const { present, children } = props;
+      const presence = usePresence(present);
+      const child = typeof children === "function" ? children({ present: presence.isPresent }) : React22.Children.only(children);
+      const ref = (0, import_react_compose_refs.useComposedRefs)(presence.ref, getElementRef(child));
+      const forceMount = typeof children === "function";
+      return forceMount || presence.isPresent ? React22.cloneElement(child, { ref }) : null;
+    };
+    Presence.displayName = "Presence";
+    function usePresence(present) {
+      const [node, setNode] = React22.useState();
+      const stylesRef = React22.useRef(null);
+      const prevPresentRef = React22.useRef(present);
+      const prevAnimationNameRef = React22.useRef("none");
+      const initialState = present ? "mounted" : "unmounted";
+      const [state, send] = useStateMachine(initialState, {
+        mounted: {
+          UNMOUNT: "unmounted",
+          ANIMATION_OUT: "unmountSuspended"
+        },
+        unmountSuspended: {
+          MOUNT: "mounted",
+          ANIMATION_END: "unmounted"
+        },
+        unmounted: {
+          MOUNT: "mounted"
+        }
+      });
+      React22.useEffect(() => {
+        const currentAnimationName = getAnimationName(stylesRef.current);
+        prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
+      }, [state]);
+      (0, import_react_use_layout_effect.useLayoutEffect)(() => {
+        const styles = stylesRef.current;
+        const wasPresent = prevPresentRef.current;
+        const hasPresentChanged = wasPresent !== present;
+        if (hasPresentChanged) {
+          const prevAnimationName = prevAnimationNameRef.current;
+          const currentAnimationName = getAnimationName(styles);
+          if (present) {
+            send("MOUNT");
+          } else if (currentAnimationName === "none" || styles?.display === "none") {
+            send("UNMOUNT");
+          } else {
+            const isAnimating = prevAnimationName !== currentAnimationName;
+            if (wasPresent && isAnimating) {
+              send("ANIMATION_OUT");
+            } else {
+              send("UNMOUNT");
+            }
+          }
+          prevPresentRef.current = present;
+        }
+      }, [present, send]);
+      (0, import_react_use_layout_effect.useLayoutEffect)(() => {
+        if (node) {
+          let timeoutId;
+          const ownerWindow = node.ownerDocument.defaultView ?? window;
+          const handleAnimationEnd = (event) => {
+            const currentAnimationName = getAnimationName(stylesRef.current);
+            const isCurrentAnimation = currentAnimationName.includes(event.animationName);
+            if (event.target === node && isCurrentAnimation) {
+              send("ANIMATION_END");
+              if (!prevPresentRef.current) {
+                const currentFillMode = node.style.animationFillMode;
+                node.style.animationFillMode = "forwards";
+                timeoutId = ownerWindow.setTimeout(() => {
+                  if (node.style.animationFillMode === "forwards") {
+                    node.style.animationFillMode = currentFillMode;
+                  }
+                });
+              }
+            }
+          };
+          const handleAnimationStart = (event) => {
+            if (event.target === node) {
+              prevAnimationNameRef.current = getAnimationName(stylesRef.current);
+            }
+          };
+          node.addEventListener("animationstart", handleAnimationStart);
+          node.addEventListener("animationcancel", handleAnimationEnd);
+          node.addEventListener("animationend", handleAnimationEnd);
+          return () => {
+            ownerWindow.clearTimeout(timeoutId);
+            node.removeEventListener("animationstart", handleAnimationStart);
+            node.removeEventListener("animationcancel", handleAnimationEnd);
+            node.removeEventListener("animationend", handleAnimationEnd);
+          };
+        } else {
+          send("ANIMATION_END");
+        }
+      }, [node, send]);
+      return {
+        isPresent: ["mounted", "unmountSuspended"].includes(state),
+        ref: React22.useCallback((node2) => {
+          stylesRef.current = node2 ? getComputedStyle(node2) : null;
+          setNode(node2);
+        }, [])
+      };
+    }
+    function getAnimationName(styles) {
+      return styles?.animationName || "none";
+    }
+    function getElementRef(element) {
+      let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+      let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+      if (mayWarn) {
+        return element.ref;
+      }
+      getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+      mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+      if (mayWarn) {
+        return element.props.ref;
+      }
+      return element.props.ref || element.ref;
+    }
+    var Root = Presence;
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-focus-guards/dist/index.js
+var require_dist64 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-focus-guards/dist/index.js"(exports, module) {
+    "use strict";
+    "use client";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      FocusGuards: () => FocusGuards,
+      Root: () => Root,
+      useFocusGuards: () => useFocusGuards
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var count = 0;
+    function FocusGuards(props) {
+      useFocusGuards();
+      return props.children;
+    }
+    function useFocusGuards() {
+      React3.useEffect(() => {
+        const edgeGuards = document.querySelectorAll("[data-radix-focus-guard]");
+        document.body.insertAdjacentElement("afterbegin", edgeGuards[0] ?? createFocusGuard());
+        document.body.insertAdjacentElement("beforeend", edgeGuards[1] ?? createFocusGuard());
+        count++;
+        return () => {
+          if (count === 1) {
+            document.querySelectorAll("[data-radix-focus-guard]").forEach((node) => node.remove());
+          }
+          count--;
+        };
+      }, []);
+    }
+    function createFocusGuard() {
+      const element = document.createElement("span");
+      element.setAttribute("data-radix-focus-guard", "");
+      element.tabIndex = 0;
+      element.style.outline = "none";
+      element.style.opacity = "0";
+      element.style.position = "fixed";
+      element.style.pointerEvents = "none";
+      return element;
+    }
+    var Root = FocusGuards;
+  }
+});
+
+// ../core/node_modules/@radix-ui/react-dialog/dist/index.js
+var require_dist65 = __commonJS({
+  "../core/node_modules/@radix-ui/react-dialog/dist/index.js"(exports, module) {
+    "use strict";
+    "use client";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from2, except, desc) => {
+      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+        for (let key of __getOwnPropNames2(from2))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      Close: () => Close,
+      Content: () => Content,
+      Description: () => Description,
+      Dialog: () => Dialog,
+      DialogClose: () => DialogClose,
+      DialogContent: () => DialogContent,
+      DialogDescription: () => DialogDescription,
+      DialogOverlay: () => DialogOverlay,
+      DialogPortal: () => DialogPortal,
+      DialogTitle: () => DialogTitle,
+      DialogTrigger: () => DialogTrigger,
+      Overlay: () => Overlay,
+      Portal: () => Portal,
+      Root: () => Root,
+      Title: () => Title2,
+      Trigger: () => Trigger,
+      WarningProvider: () => WarningProvider,
+      createDialogScope: () => createDialogScope
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var React3 = __toESM2(require_react());
+    var import_primitive = require_dist45();
+    var import_react_compose_refs = require_dist46();
+    var import_react_context = require_dist47();
+    var import_react_id = require_dist49();
+    var import_react_use_controllable_state = require_dist51();
+    var import_react_dismissable_layer = require_dist57();
+    var import_react_focus_scope = require_dist59();
+    var import_react_portal = require_dist61();
+    var import_react_presence = require_dist63();
+    var import_react_primitive = require_dist54();
+    var import_react_focus_guards = require_dist64();
+    var import_react_remove_scroll = require_es57();
+    var import_aria_hidden = require_es5();
+    var import_react_slot = require_dist53();
+    var import_jsx_runtime44 = require_jsx_runtime();
+    var DIALOG_NAME = "Dialog";
+    var [createDialogContext, createDialogScope] = (0, import_react_context.createContextScope)(DIALOG_NAME);
+    var [DialogProvider, useDialogContext] = createDialogContext(DIALOG_NAME);
+    var Dialog = (props) => {
+      const {
+        __scopeDialog,
+        children,
+        open: openProp,
+        defaultOpen,
+        onOpenChange,
+        modal = true
+      } = props;
+      const triggerRef = React3.useRef(null);
+      const contentRef = React3.useRef(null);
+      const [open, setOpen] = (0, import_react_use_controllable_state.useControllableState)({
+        prop: openProp,
+        defaultProp: defaultOpen ?? false,
+        onChange: onOpenChange,
+        caller: DIALOG_NAME
+      });
+      return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+        DialogProvider,
+        {
+          scope: __scopeDialog,
+          triggerRef,
+          contentRef,
+          contentId: (0, import_react_id.useId)(),
+          titleId: (0, import_react_id.useId)(),
+          descriptionId: (0, import_react_id.useId)(),
+          open,
+          onOpenChange: setOpen,
+          onOpenToggle: React3.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
+          modal,
+          children
+        }
+      );
+    };
+    Dialog.displayName = DIALOG_NAME;
+    var TRIGGER_NAME = "DialogTrigger";
+    var DialogTrigger = React3.forwardRef(
+      (props, forwardedRef) => {
+        const { __scopeDialog, ...triggerProps } = props;
+        const context = useDialogContext(TRIGGER_NAME, __scopeDialog);
+        const composedTriggerRef = (0, import_react_compose_refs.useComposedRefs)(forwardedRef, context.triggerRef);
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+          import_react_primitive.Primitive.button,
+          {
+            type: "button",
+            "aria-haspopup": "dialog",
+            "aria-expanded": context.open,
+            "aria-controls": context.contentId,
+            "data-state": getState(context.open),
+            ...triggerProps,
+            ref: composedTriggerRef,
+            onClick: (0, import_primitive.composeEventHandlers)(props.onClick, context.onOpenToggle)
+          }
+        );
+      }
+    );
+    DialogTrigger.displayName = TRIGGER_NAME;
+    var PORTAL_NAME = "DialogPortal";
+    var [PortalProvider, usePortalContext] = createDialogContext(PORTAL_NAME, {
+      forceMount: void 0
+    });
+    var DialogPortal = (props) => {
+      const { __scopeDialog, forceMount, children, container } = props;
+      const context = useDialogContext(PORTAL_NAME, __scopeDialog);
+      return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(PortalProvider, { scope: __scopeDialog, forceMount, children: React3.Children.map(children, (child) => /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_presence.Presence, { present: forceMount || context.open, children: /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_portal.Portal, { asChild: true, container, children: child }) })) });
+    };
+    DialogPortal.displayName = PORTAL_NAME;
+    var OVERLAY_NAME = "DialogOverlay";
+    var DialogOverlay = React3.forwardRef(
+      (props, forwardedRef) => {
+        const portalContext = usePortalContext(OVERLAY_NAME, props.__scopeDialog);
+        const { forceMount = portalContext.forceMount, ...overlayProps } = props;
+        const context = useDialogContext(OVERLAY_NAME, props.__scopeDialog);
+        return context.modal ? /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_presence.Presence, { present: forceMount || context.open, children: /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(DialogOverlayImpl, { ...overlayProps, ref: forwardedRef }) }) : null;
+      }
+    );
+    DialogOverlay.displayName = OVERLAY_NAME;
+    var Slot = (0, import_react_slot.createSlot)("DialogOverlay.RemoveScroll");
+    var DialogOverlayImpl = React3.forwardRef(
+      (props, forwardedRef) => {
+        const { __scopeDialog, ...overlayProps } = props;
+        const context = useDialogContext(OVERLAY_NAME, __scopeDialog);
+        return (
+          // Make sure `Content` is scrollable even when it doesn't live inside `RemoveScroll`
+          // ie. when `Overlay` and `Content` are siblings
+          /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_remove_scroll.RemoveScroll, { as: Slot, allowPinchZoom: true, shards: [context.contentRef], children: /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+            import_react_primitive.Primitive.div,
+            {
+              "data-state": getState(context.open),
+              ...overlayProps,
+              ref: forwardedRef,
+              style: { pointerEvents: "auto", ...overlayProps.style }
+            }
+          ) })
+        );
+      }
+    );
+    var CONTENT_NAME = "DialogContent";
+    var DialogContent = React3.forwardRef(
+      (props, forwardedRef) => {
+        const portalContext = usePortalContext(CONTENT_NAME, props.__scopeDialog);
+        const { forceMount = portalContext.forceMount, ...contentProps } = props;
+        const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_presence.Presence, { present: forceMount || context.open, children: context.modal ? /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(DialogContentModal, { ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(DialogContentNonModal, { ...contentProps, ref: forwardedRef }) });
+      }
+    );
+    DialogContent.displayName = CONTENT_NAME;
+    var DialogContentModal = React3.forwardRef(
+      (props, forwardedRef) => {
+        const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
+        const contentRef = React3.useRef(null);
+        const composedRefs = (0, import_react_compose_refs.useComposedRefs)(forwardedRef, context.contentRef, contentRef);
+        React3.useEffect(() => {
+          const content = contentRef.current;
+          if (content)
+            return (0, import_aria_hidden.hideOthers)(content);
+        }, []);
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+          DialogContentImpl,
+          {
+            ...props,
+            ref: composedRefs,
+            trapFocus: context.open,
+            disableOutsidePointerEvents: true,
+            onCloseAutoFocus: (0, import_primitive.composeEventHandlers)(props.onCloseAutoFocus, (event) => {
+              event.preventDefault();
+              context.triggerRef.current?.focus();
+            }),
+            onPointerDownOutside: (0, import_primitive.composeEventHandlers)(props.onPointerDownOutside, (event) => {
+              const originalEvent = event.detail.originalEvent;
+              const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
+              const isRightClick = originalEvent.button === 2 || ctrlLeftClick;
+              if (isRightClick)
+                event.preventDefault();
+            }),
+            onFocusOutside: (0, import_primitive.composeEventHandlers)(
+              props.onFocusOutside,
+              (event) => event.preventDefault()
+            )
+          }
+        );
+      }
+    );
+    var DialogContentNonModal = React3.forwardRef(
+      (props, forwardedRef) => {
+        const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
+        const hasInteractedOutsideRef = React3.useRef(false);
+        const hasPointerDownOutsideRef = React3.useRef(false);
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+          DialogContentImpl,
+          {
+            ...props,
+            ref: forwardedRef,
+            trapFocus: false,
+            disableOutsidePointerEvents: false,
+            onCloseAutoFocus: (event) => {
+              props.onCloseAutoFocus?.(event);
+              if (!event.defaultPrevented) {
+                if (!hasInteractedOutsideRef.current)
+                  context.triggerRef.current?.focus();
+                event.preventDefault();
+              }
+              hasInteractedOutsideRef.current = false;
+              hasPointerDownOutsideRef.current = false;
+            },
+            onInteractOutside: (event) => {
+              props.onInteractOutside?.(event);
+              if (!event.defaultPrevented) {
+                hasInteractedOutsideRef.current = true;
+                if (event.detail.originalEvent.type === "pointerdown") {
+                  hasPointerDownOutsideRef.current = true;
+                }
+              }
+              const target = event.target;
+              const targetIsTrigger = context.triggerRef.current?.contains(target);
+              if (targetIsTrigger)
+                event.preventDefault();
+              if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.current) {
+                event.preventDefault();
+              }
+            }
+          }
+        );
+      }
+    );
+    var DialogContentImpl = React3.forwardRef(
+      (props, forwardedRef) => {
+        const { __scopeDialog, trapFocus, onOpenAutoFocus, onCloseAutoFocus, ...contentProps } = props;
+        const context = useDialogContext(CONTENT_NAME, __scopeDialog);
+        const contentRef = React3.useRef(null);
+        const composedRefs = (0, import_react_compose_refs.useComposedRefs)(forwardedRef, contentRef);
+        (0, import_react_focus_guards.useFocusGuards)();
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(import_jsx_runtime44.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+            import_react_focus_scope.FocusScope,
+            {
+              asChild: true,
+              loop: true,
+              trapped: trapFocus,
+              onMountAutoFocus: onOpenAutoFocus,
+              onUnmountAutoFocus: onCloseAutoFocus,
+              children: /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+                import_react_dismissable_layer.DismissableLayer,
+                {
+                  role: "dialog",
+                  id: context.contentId,
+                  "aria-describedby": context.descriptionId,
+                  "aria-labelledby": context.titleId,
+                  "data-state": getState(context.open),
+                  ...contentProps,
+                  ref: composedRefs,
+                  onDismiss: () => context.onOpenChange(false)
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(import_jsx_runtime44.Fragment, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(TitleWarning, { titleId: context.titleId }),
+            /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(DescriptionWarning, { contentRef, descriptionId: context.descriptionId })
+          ] })
+        ] });
+      }
+    );
+    var TITLE_NAME = "DialogTitle";
+    var DialogTitle = React3.forwardRef(
+      (props, forwardedRef) => {
+        const { __scopeDialog, ...titleProps } = props;
+        const context = useDialogContext(TITLE_NAME, __scopeDialog);
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_primitive.Primitive.h2, { id: context.titleId, ...titleProps, ref: forwardedRef });
+      }
+    );
+    DialogTitle.displayName = TITLE_NAME;
+    var DESCRIPTION_NAME = "DialogDescription";
+    var DialogDescription = React3.forwardRef(
+      (props, forwardedRef) => {
+        const { __scopeDialog, ...descriptionProps } = props;
+        const context = useDialogContext(DESCRIPTION_NAME, __scopeDialog);
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_primitive.Primitive.p, { id: context.descriptionId, ...descriptionProps, ref: forwardedRef });
+      }
+    );
+    DialogDescription.displayName = DESCRIPTION_NAME;
+    var CLOSE_NAME = "DialogClose";
+    var DialogClose = React3.forwardRef(
+      (props, forwardedRef) => {
+        const { __scopeDialog, ...closeProps } = props;
+        const context = useDialogContext(CLOSE_NAME, __scopeDialog);
+        return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+          import_react_primitive.Primitive.button,
+          {
+            type: "button",
+            ...closeProps,
+            ref: forwardedRef,
+            onClick: (0, import_primitive.composeEventHandlers)(props.onClick, () => context.onOpenChange(false))
+          }
+        );
+      }
+    );
+    DialogClose.displayName = CLOSE_NAME;
+    function getState(open) {
+      return open ? "open" : "closed";
+    }
+    var TITLE_WARNING_NAME = "DialogTitleWarning";
+    var [WarningProvider, useWarningContext] = (0, import_react_context.createContext)(TITLE_WARNING_NAME, {
+      contentName: CONTENT_NAME,
+      titleName: TITLE_NAME,
+      docsSlug: "dialog"
+    });
+    var TitleWarning = ({ titleId }) => {
+      const titleWarningContext = useWarningContext(TITLE_WARNING_NAME);
+      const MESSAGE = `\`${titleWarningContext.contentName}\` requires a \`${titleWarningContext.titleName}\` for the component to be accessible for screen reader users.
+
+If you want to hide the \`${titleWarningContext.titleName}\`, you can wrap it with our VisuallyHidden component.
+
+For more information, see https://radix-ui.com/primitives/docs/components/${titleWarningContext.docsSlug}`;
+      React3.useEffect(() => {
+        if (titleId) {
+          const hasTitle = document.getElementById(titleId);
+          if (!hasTitle)
+            console.error(MESSAGE);
+        }
+      }, [MESSAGE, titleId]);
+      return null;
+    };
+    var DESCRIPTION_WARNING_NAME = "DialogDescriptionWarning";
+    var DescriptionWarning = ({ contentRef, descriptionId }) => {
+      const descriptionWarningContext = useWarningContext(DESCRIPTION_WARNING_NAME);
+      const MESSAGE = `Warning: Missing \`Description\` or \`aria-describedby={undefined}\` for {${descriptionWarningContext.contentName}}.`;
+      React3.useEffect(() => {
+        const describedById = contentRef.current?.getAttribute("aria-describedby");
+        if (descriptionId && describedById) {
+          const hasDescription = document.getElementById(descriptionId);
+          if (!hasDescription)
+            console.warn(MESSAGE);
+        }
+      }, [MESSAGE, contentRef, descriptionId]);
+      return null;
+    };
+    var Root = Dialog;
+    var Trigger = DialogTrigger;
+    var Portal = DialogPortal;
+    var Overlay = DialogOverlay;
+    var Content = DialogContent;
+    var Title2 = DialogTitle;
+    var Description = DialogDescription;
+    var Close = DialogClose;
+  }
+});
+
 // ../core/lib/client/jsx/shadcn-ui/dialog.js
 var require_dialog = __commonJS({
   "../core/lib/client/jsx/shadcn-ui/dialog.js"(exports) {
@@ -57787,7 +60057,7 @@ var require_dialog = __commonJS({
     exports.DialogTrigger = DialogTrigger;
     var jsx_runtime_1 = require_jsx_runtime();
     var React3 = __importStar2(require_react());
-    var DialogPrimitive = __importStar2(require_dist43());
+    var DialogPrimitive = __importStar2(require_dist65());
     var lucide_react_1 = require_lucide_react();
     var tailwind_merge_1 = require_bundle_cjs();
     function Dialog({ ...props }) {
@@ -57829,6 +60099,38 @@ var require_dialog = __commonJS({
 var require_command = __commonJS({
   "../core/lib/client/jsx/shadcn-ui/command.js"(exports) {
     "use strict";
+    var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result2 = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding2(result2, mod, k);
+      }
+      __setModuleDefault2(result2, mod);
+      return result2;
+    };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Command = Command2;
     exports.CommandDialog = CommandDialog2;
@@ -57839,11 +60141,14 @@ var require_command = __commonJS({
     exports.CommandItem = CommandItem2;
     exports.CommandShortcut = CommandShortcut;
     exports.CommandSeparator = CommandSeparator2;
+    exports.SearchInput = SearchInput;
     var jsx_runtime_1 = require_jsx_runtime();
+    var React3 = __importStar2(require_react());
     var cmdk_1 = require_dist44();
     var lucide_react_1 = require_lucide_react();
     var tailwind_merge_1 = require_bundle_cjs();
     var dialog_1 = require_dialog();
+    var input_1 = require_input();
     function Command2({ className, ...props }) {
       return (0, jsx_runtime_1.jsx)(cmdk_1.Command, { "data-slot": "command", className: (0, tailwind_merge_1.twMerge)("bg-white text-gray-900 dark:bg-gray-800 dark:text-white flex h-full w-full flex-col overflow-hidden rounded-lg", className), ...props });
     }
@@ -57851,7 +60156,11 @@ var require_command = __commonJS({
       return (0, jsx_runtime_1.jsxs)(dialog_1.Dialog, { ...props, children: [(0, jsx_runtime_1.jsxs)(dialog_1.DialogHeader, { className: "sr-only", children: [(0, jsx_runtime_1.jsx)(dialog_1.DialogTitle, { children: title }), (0, jsx_runtime_1.jsx)(dialog_1.DialogDescription, { children: description })] }), (0, jsx_runtime_1.jsx)(dialog_1.DialogContent, { className: "overflow-hidden p-0", children: (0, jsx_runtime_1.jsx)(Command2, { className: "[&_[cmdk-group-heading]]:text-gray-500 dark:[&_[cmdk-group-heading]]:text-gray-400 [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group]]:px-2 [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5", children }) })] });
     }
     function CommandInput2({ className, ...props }) {
-      return (0, jsx_runtime_1.jsxs)("div", { "data-slot": "command-input-wrapper", className: "flex h-8 items-center gap-2 border-b border-gray-200 dark:border-gray-600 px-3", children: [(0, jsx_runtime_1.jsx)(lucide_react_1.SearchIcon, { className: "size-4 shrink-0 text-gray-500 dark:text-gray-400" }), (0, jsx_runtime_1.jsx)(cmdk_1.Command.Input, { "data-slot": "command-input", className: (0, tailwind_merge_1.twMerge)("placeholder:text-gray-500 dark:placeholder:text-gray-400 flex h-10 w-full rounded-md bg-transparent py-3 text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50 focus:outline-none focus:ring-0 focus:ring-offset-0", className), ...props })] });
+      return (0, jsx_runtime_1.jsxs)("div", { "data-slot": "command-input-wrapper", className: "flex h-8 items-center gap-2 border-b border-gray-200 dark:border-gray-600 px-3", children: [(0, jsx_runtime_1.jsx)(lucide_react_1.SearchIcon, { className: "size-4 shrink-0 text-gray-500 dark:text-gray-400" }), (0, jsx_runtime_1.jsx)(cmdk_1.Command.Input, { "data-slot": "command-input", className: (0, tailwind_merge_1.twMerge)("placeholder:text-gray-500 dark:placeholder:text-gray-400 flex h-8 w-full rounded-md border-b border-gray-200 dark:border-gray-700 bg-transparent py-3 text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50", className), ...props })] });
+    }
+    function SearchInput({ className, ...props }) {
+      const [focused, setFocused] = React3.useState(false);
+      return (0, jsx_runtime_1.jsxs)("div", { "data-slot": "search-input-wrapper", className: (0, tailwind_merge_1.twMerge)("flex h-8 items-center gap-2 border border-gray-200 dark:border-gray-700 rounded-md px-2", focused && "border-blue-500 dark:border-blue-500", className), children: [(0, jsx_runtime_1.jsx)(lucide_react_1.SearchIcon, { className: "size-4 shrink-0 text-gray-500 dark:text-gray-400" }), (0, jsx_runtime_1.jsx)(input_1.Input, { type: "text", onFocus: () => setFocused(true), onBlur: () => setFocused(false), "data-slot": "search-input", className: (0, tailwind_merge_1.twMerge)("border-none placeholder:text-gray-500 dark:placeholder:text-gray-400 flex h-full w-full px-0 bg-transparent text-base font-normal outline-hidden disabled:cursor-not-allowed disabled:opacity-50"), ...props })] });
     }
     function CommandList2({ className, ...props }) {
       return (0, jsx_runtime_1.jsx)(cmdk_1.Command.List, { "data-slot": "command-list", className: (0, tailwind_merge_1.twMerge)("max-h-[300px] scroll-py-1 overflow-x-hidden overflow-y-auto", className), ...props });
@@ -58427,7 +60736,7 @@ var require_utilities_cjs_development = __commonJS({
 });
 
 // ../../node_modules/@dnd-kit/utilities/dist/index.js
-var require_dist45 = __commonJS({
+var require_dist66 = __commonJS({
   "../../node_modules/@dnd-kit/utilities/dist/index.js"(exports, module) {
     "use strict";
     if (false) {
@@ -58508,7 +60817,7 @@ var require_accessibility_cjs_development = __commonJS({
 });
 
 // ../../node_modules/@dnd-kit/accessibility/dist/index.js
-var require_dist46 = __commonJS({
+var require_dist67 = __commonJS({
   "../../node_modules/@dnd-kit/accessibility/dist/index.js"(exports, module) {
     "use strict";
     if (false) {
@@ -58530,8 +60839,8 @@ var require_core_cjs_development = __commonJS({
     var React3 = require_react();
     var React__default = _interopDefault(React3);
     var reactDom = require_react_dom();
-    var utilities = require_dist45();
-    var accessibility = require_dist46();
+    var utilities = require_dist66();
+    var accessibility = require_dist67();
     var DndMonitorContext = /* @__PURE__ */ React3.createContext(null);
     function useDndMonitor(listener) {
       const registerListener = React3.useContext(DndMonitorContext);
@@ -62019,7 +64328,7 @@ var require_core_cjs_development = __commonJS({
 });
 
 // ../../node_modules/@dnd-kit/core/dist/index.js
-var require_dist47 = __commonJS({
+var require_dist68 = __commonJS({
   "../../node_modules/@dnd-kit/core/dist/index.js"(exports, module) {
     "use strict";
     if (false) {
@@ -62040,8 +64349,8 @@ var require_sortable_cjs_development = __commonJS({
     }
     var React3 = require_react();
     var React__default = _interopDefault(React3);
-    var core = require_dist47();
-    var utilities = require_dist45();
+    var core = require_dist68();
+    var utilities = require_dist66();
     function arrayMove(array, from2, to2) {
       const newArray = array.slice();
       newArray.splice(to2 < 0 ? newArray.length + to2 : to2, 0, newArray.splice(from2, 1)[0]);
@@ -62732,7 +65041,7 @@ var require_sortable_cjs_development = __commonJS({
 });
 
 // ../../node_modules/@dnd-kit/sortable/dist/index.js
-var require_dist48 = __commonJS({
+var require_dist69 = __commonJS({
   "../../node_modules/@dnd-kit/sortable/dist/index.js"(exports, module) {
     "use strict";
     if (false) {
@@ -62765,9 +65074,9 @@ var require_advanced_stream_mapping = __commonJS({
     var util_1 = require_util();
     var language_selector_1 = require_language_selector();
     var react_2 = __importDefault2(require_react());
-    var utilities_1 = require_dist45();
-    var core_1 = require_dist47();
-    var sortable_1 = require_dist48();
+    var utilities_1 = require_dist66();
+    var core_1 = require_dist68();
+    var sortable_1 = require_dist69();
     var lucide_react_2 = require_lucide_react();
     var util_2 = require_util();
     function advancedStreamMappingEditor(defaultValue, data) {