babavoss 0.0.0-stage → 0.0.2

package/gui/chunk-k3cm8j6r.js

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

package/gui/chunk-pk09y98y.js

@@ -0,0 +1,50 @@
+import {
+  __commonJS,
+  __esm,
+  __export
+} from "./chunk-wwqypxre.js";
+
+// ../../node_modules/.bun/react@19.3.0/node_modules/react/cjs/react-jsx-runtime.production.js
+var exports_react_jsx_runtime_production = {};
+__export(exports_react_jsx_runtime_production, {
+  Fragment: () => $Fragment,
+  jsx: () => $jsx,
+  jsxs: () => $jsxs
+});
+function jsxProd(type, config, maybeKey) {
+  var key = null;
+  maybeKey !== undefined && (key = "" + maybeKey);
+  config.key !== undefined && (key = "" + config.key);
+  if ("key" in config) {
+    maybeKey = {};
+    for (var propName in config)
+      propName !== "key" && (maybeKey[propName] = config[propName]);
+  } else
+    maybeKey = config;
+  config = maybeKey.ref;
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type,
+    key,
+    ref: config !== undefined ? config : null,
+    props: maybeKey
+  };
+}
+var REACT_ELEMENT_TYPE, REACT_FRAGMENT_TYPE, $Fragment, $jsx, $jsxs;
+var init_react_jsx_runtime_production = __esm(() => {
+  REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  $Fragment = REACT_FRAGMENT_TYPE;
+  $jsx = jsxProd;
+  $jsxs = jsxProd;
+});
+
+// ../../node_modules/.bun/react@19.3.0/node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS(function(exports, module) {
+  init_react_jsx_runtime_production();
+  if (true) {
+    module.exports = exports_react_jsx_runtime_production;
+  }
+});
+
+export { require_jsx_runtime };

package/gui/chunk-smz02qa6.js

@@ -0,0 +1,186 @@
+import {
+  require_react
+} from "./chunk-k3cm8j6r.js";
+import {
+  __commonJS,
+  __esm,
+  __export,
+  __toESM
+} from "./chunk-wwqypxre.js";
+
+// ../../node_modules/.bun/react-dom@19.3.0+62547eec5a2188e3/node_modules/react-dom/cjs/react-dom.production.js
+var exports_react_dom_production = {};
+__export(exports_react_dom_production, {
+  __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE: () => $__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+  browser: () => $browser,
+  createPortal: () => $createPortal,
+  flushSync: () => $flushSync,
+  preconnect: () => $preconnect,
+  prefetchDNS: () => $prefetchDNS,
+  preinit: () => $preinit,
+  preinitModule: () => $preinitModule,
+  preload: () => $preload,
+  preloadModule: () => $preloadModule,
+  requestFormReset: () => $requestFormReset,
+  unstable_batchedUpdates: () => $unstable_batchedUpdates,
+  useFormState: () => $useFormState,
+  useFormStatus: () => $useFormStatus,
+  version: () => $version
+});
+function formatProdErrorMessage(code) {
+  var url = "https://react.dev/errors/" + code;
+  if (1 < arguments.length) {
+    url += "?args[]=" + encodeURIComponent(arguments[1]);
+    for (var i = 2;i < arguments.length; i++)
+      url += "&args[]=" + encodeURIComponent(arguments[i]);
+  }
+  return "Minified React error #" + code + "; visit " + url + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+}
+function noop() {}
+function createPortal$1(children, containerInfo, implementation) {
+  var key = 3 < arguments.length && arguments[3] !== undefined ? arguments[3] : null;
+  return {
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : key === REACT_OPTIMISTIC_KEY ? REACT_OPTIMISTIC_KEY : "" + key,
+    children,
+    containerInfo,
+    implementation
+  };
+}
+function getCrossOriginStringAs(as, input) {
+  if (as === "font")
+    return "";
+  if (typeof input === "string")
+    return input === "use-credentials" ? input : "";
+}
+var React, Internals, REACT_PORTAL_TYPE, REACT_RECOVERABLE_TYPE, REACT_OPTIMISTIC_KEY, ReactSharedInternals, $__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, $browser = function(reason) {
+  return { $$typeof: REACT_RECOVERABLE_TYPE, _reason: reason };
+}, $createPortal = function(children, container) {
+  var key = 2 < arguments.length && arguments[2] !== undefined ? arguments[2] : null;
+  if (!container || container.nodeType !== 1 && container.nodeType !== 9 && container.nodeType !== 11)
+    throw Error(formatProdErrorMessage(299));
+  return createPortal$1(children, container, null, key);
+}, $flushSync = function(fn) {
+  var previousTransition = ReactSharedInternals.T, previousUpdatePriority = Internals.p;
+  try {
+    if (ReactSharedInternals.T = null, Internals.p = 2, fn)
+      return fn();
+  } finally {
+    ReactSharedInternals.T = previousTransition, Internals.p = previousUpdatePriority, Internals.d.f();
+  }
+}, $preconnect = function(href, options) {
+  typeof href === "string" && (options ? (options = options.crossOrigin, options = typeof options === "string" ? options === "use-credentials" ? options : "" : undefined) : options = null, Internals.d.C(href, options));
+}, $prefetchDNS = function(href) {
+  typeof href === "string" && Internals.d.D(href);
+}, $preinit = function(href, options) {
+  if (typeof href === "string" && options && typeof options.as === "string") {
+    var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin), integrity = typeof options.integrity === "string" ? options.integrity : undefined, fetchPriority = typeof options.fetchPriority === "string" ? options.fetchPriority : undefined;
+    as === "style" ? Internals.d.S(href, typeof options.precedence === "string" ? options.precedence : undefined, {
+      crossOrigin,
+      integrity,
+      fetchPriority
+    }) : as === "script" && Internals.d.X(href, {
+      crossOrigin,
+      integrity,
+      fetchPriority,
+      nonce: typeof options.nonce === "string" ? options.nonce : undefined
+    });
+  }
+}, $preinitModule = function(href, options) {
+  if (typeof href === "string")
+    if (typeof options === "object" && options !== null) {
+      if (options.as == null || options.as === "script") {
+        var crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+        Internals.d.M(href, {
+          crossOrigin,
+          integrity: typeof options.integrity === "string" ? options.integrity : undefined,
+          nonce: typeof options.nonce === "string" ? options.nonce : undefined,
+          fetchPriority: typeof options.fetchPriority === "string" ? options.fetchPriority : undefined
+        });
+      }
+    } else
+      options == null && Internals.d.M(href);
+}, $preload = function(href, options) {
+  if (typeof href === "string" && typeof options === "object" && options !== null && typeof options.as === "string") {
+    var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+    Internals.d.L(href, as, {
+      crossOrigin,
+      integrity: typeof options.integrity === "string" ? options.integrity : undefined,
+      nonce: typeof options.nonce === "string" ? options.nonce : undefined,
+      type: typeof options.type === "string" ? options.type : undefined,
+      fetchPriority: typeof options.fetchPriority === "string" ? options.fetchPriority : undefined,
+      referrerPolicy: typeof options.referrerPolicy === "string" ? options.referrerPolicy : undefined,
+      imageSrcSet: typeof options.imageSrcSet === "string" ? options.imageSrcSet : undefined,
+      imageSizes: typeof options.imageSizes === "string" ? options.imageSizes : undefined,
+      media: typeof options.media === "string" ? options.media : undefined
+    });
+  }
+}, $preloadModule = function(href, options) {
+  if (typeof href === "string")
+    if (options) {
+      var crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+      Internals.d.m(href, {
+        as: typeof options.as === "string" && options.as !== "script" ? options.as : undefined,
+        crossOrigin,
+        integrity: typeof options.integrity === "string" ? options.integrity : undefined,
+        nonce: typeof options.nonce === "string" ? options.nonce : undefined,
+        fetchPriority: typeof options.fetchPriority === "string" ? options.fetchPriority : undefined
+      });
+    } else
+      Internals.d.m(href);
+}, $requestFormReset = function(form) {
+  Internals.d.r(form);
+}, $unstable_batchedUpdates = function(fn, a) {
+  return fn(a);
+}, $useFormState = function(action, initialState, permalink) {
+  return ReactSharedInternals.H.useFormState(action, initialState, permalink);
+}, $useFormStatus = function() {
+  return ReactSharedInternals.H.useHostTransitionStatus();
+}, $version = "19.3.0";
+var init_react_dom_production = __esm(() => {
+  React = __toESM(require_react(), 1);
+  Internals = {
+    d: {
+      f: noop,
+      r: function() {
+        throw Error(formatProdErrorMessage(522));
+      },
+      D: noop,
+      C: noop,
+      L: noop,
+      m: noop,
+      X: noop,
+      S: noop,
+      M: noop
+    },
+    p: 0,
+    findDOMNode: null
+  };
+  REACT_PORTAL_TYPE = Symbol.for("react.portal");
+  REACT_RECOVERABLE_TYPE = Symbol.for("react.recoverable");
+  REACT_OPTIMISTIC_KEY = Symbol.for("react.optimistic_key");
+  ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  $__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals;
+});
+
+// ../../node_modules/.bun/react-dom@19.3.0+62547eec5a2188e3/node_modules/react-dom/index.js
+var require_react_dom = __commonJS(function(exports, module) {
+  init_react_dom_production();
+  function checkDCE() {
+    if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== "function") {
+      return;
+    }
+    if (false) {}
+    try {
+      __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
+    } catch (err) {
+      console.error(err);
+    }
+  }
+  if (true) {
+    checkDCE();
+    module.exports = exports_react_dom_production;
+  }
+});
+
+export { require_react_dom };