@gaddario98/react-core 2.0.8 → 2.0.9

package/dist/form/index.mjs

@@ -1,2987 +1,240 @@
-import {atomStateGenerator}from'@gaddario98/react-state';import {c}from'react/compiler-runtime';import {jsx,Fragment,jsxs}from'react/jsx-runtime';import*as React from'react';import React__default,{useLayoutEffect,useEffect,useMemo,useState,useRef,useCallback,useReducer,useDebugValue,useContext,createContext}from'react';import equal from'fast-deep-equal';import {useSyncExternalStoreWithSelector}from'use-sync-external-store/shim/with-selector.js';const DefaultContainer$1 = ({
-  children
-}) => {
-  return children;
-};
-// Lazy initialization to avoid side effects at module load time
-const _formConfig = {
-  formFieldContainer: DefaultContainer$1
-};
-const {
-  atom: formConfigAtom,
-  useValue: useFormConfigValue,
-  useState: useFormConfigState,
-  useReset: useFormConfigReset
-} = atomStateGenerator({
-  key: 'formConfig',
-  defaultValue: _formConfig,
-  persist: false
-});const createDefaultContainer = () => {
-  return ({
-    children
-  }) => {
-    return children;
-  };
-};
-let DefaultContainer = createDefaultContainer();
-const setDefaultFormContainer = val => {
-  DefaultContainer = val;
-};
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const DefaultFormContainer = t0 => {
-  const $ = c(2);
+import {c}from'react/compiler-runtime';import {atom,useAtom,useAtomValue,useSetAtom}from'jotai';import {atomWithStorage,createJSONStorage,selectAtom}from'jotai/utils';import {inflateSync,strFromU8,strToU8,deflateSync}from'fflate';import {jsx,Fragment,jsxs}from'react/jsx-runtime';import {useMemo,useRef,useEffect,useCallback,useState}from'react';import equal from'fast-deep-equal';import {useForm}from'@tanstack/react-form';const RAW_PREFIX = 'storage:raw:';
+const DEFLATE_PREFIX = 'storage:deflate:v1:';
+const isProbablyJson = value => {
+  if (!value) return false;
+  const c = value.charCodeAt(0);
+  // { [ " digits, t/f/n (true/false/null)
+  return c === 123 || c === 91 || c === 34 || c >= 48 && c <= 57 || c === 45 || c === 116 || c === 102 || c === 110;
+};
+const u8ToBase64 = bytes => {
+  let binary = '';
+  const chunkSize = 0x8000;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+  }
+  return btoa(binary);
+};
+const base64ToU8 = base64 => {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+};
+const createCompressedStorage = (base, options = {}) => {
   const {
-    children
-  } = t0;
-  const handleSubmit = _temp$1;
-  let t1;
-  if ($[0] !== children) {
-    t1 = jsx("form", {
-      onSubmit: handleSubmit,
-      className: "gap-3 flex flex-col",
-      children
-    });
-    $[0] = children;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  return t1;
-};
-function _temp$1(e) {
-  e.preventDefault();
-  const form = e.currentTarget;
-  const submitButton = form.querySelector("button[type=\"submit\"]");
-  submitButton === null || submitButton === void 0 ? void 0 : submitButton.click();
-}const __storeToDerived = /* @__PURE__ */new WeakMap();
-const __derivedToStore = /* @__PURE__ */new WeakMap();
-const __depsThatHaveWrittenThisTick = {
-  current: []
-};
-let __isFlushing = false;
-let __batchDepth = 0;
-const __pendingUpdates = /* @__PURE__ */new Set();
-const __initialBatchValues = /* @__PURE__ */new Map();
-function __flush_internals(relatedVals) {
-  const sorted = Array.from(relatedVals).sort((a, b) => {
-    if (a instanceof Derived && a.options.deps.includes(b)) return 1;
-    if (b instanceof Derived && b.options.deps.includes(a)) return -1;
-    return 0;
-  });
-  for (const derived of sorted) {
-    if (__depsThatHaveWrittenThisTick.current.includes(derived)) {
-      continue;
-    }
-    __depsThatHaveWrittenThisTick.current.push(derived);
-    derived.recompute();
-    const stores = __derivedToStore.get(derived);
-    if (stores) {
-      for (const store of stores) {
-        const relatedLinkedDerivedVals = __storeToDerived.get(store);
-        if (!relatedLinkedDerivedVals) continue;
-        __flush_internals(relatedLinkedDerivedVals);
-      }
-    }
-  }
-}
-function __notifyListeners(store) {
-  const value = {
-    prevVal: store.prevState,
-    currentVal: store.state
-  };
-  for (const listener of store.listeners) {
-    listener(value);
-  }
-}
-function __notifyDerivedListeners(derived) {
-  const value = {
-    prevVal: derived.prevState,
-    currentVal: derived.state
-  };
-  for (const listener of derived.listeners) {
-    listener(value);
-  }
-}
-function __flush(store) {
-  if (__batchDepth > 0 && !__initialBatchValues.has(store)) {
-    __initialBatchValues.set(store, store.prevState);
-  }
-  __pendingUpdates.add(store);
-  if (__batchDepth > 0) return;
-  if (__isFlushing) return;
-  try {
-    __isFlushing = true;
-    while (__pendingUpdates.size > 0) {
-      const stores = Array.from(__pendingUpdates);
-      __pendingUpdates.clear();
-      for (const store2 of stores) {
-        const prevState = __initialBatchValues.get(store2) ?? store2.prevState;
-        store2.prevState = prevState;
-        __notifyListeners(store2);
-      }
-      for (const store2 of stores) {
-        const derivedVals = __storeToDerived.get(store2);
-        if (!derivedVals) continue;
-        __depsThatHaveWrittenThisTick.current.push(store2);
-        __flush_internals(derivedVals);
-      }
-      for (const store2 of stores) {
-        const derivedVals = __storeToDerived.get(store2);
-        if (!derivedVals) continue;
-        for (const derived of derivedVals) {
-          __notifyDerivedListeners(derived);
-        }
-      }
-    }
-  } finally {
-    __isFlushing = false;
-    __depsThatHaveWrittenThisTick.current = [];
-    __initialBatchValues.clear();
-  }
-}
-function batch(fn) {
-  __batchDepth++;
-  try {
-    fn();
-  } finally {
-    __batchDepth--;
-    if (__batchDepth === 0) {
-      const pendingUpdateToFlush = __pendingUpdates.values().next().value;
-      if (pendingUpdateToFlush) {
-        __flush(pendingUpdateToFlush);
-      }
-    }
-  }
-}function isUpdaterFunction(updater) {
-  return typeof updater === "function";
-}class Store {
-  constructor(initialState, options) {
-    this.listeners = /* @__PURE__ */new Set();
-    this.subscribe = listener => {
-      var _a, _b;
-      this.listeners.add(listener);
-      const unsub = (_b = (_a = this.options) == null ? void 0 : _a.onSubscribe) == null ? void 0 : _b.call(_a, listener, this);
-      return () => {
-        this.listeners.delete(listener);
-        unsub == null ? void 0 : unsub();
-      };
-    };
-    this.prevState = initialState;
-    this.state = initialState;
-    this.options = options;
-  }
-  setState(updater) {
-    var _a, _b, _c;
-    this.prevState = this.state;
-    if ((_a = this.options) == null ? void 0 : _a.updateFn) {
-      this.state = this.options.updateFn(this.prevState)(updater);
-    } else {
-      if (isUpdaterFunction(updater)) {
-        this.state = updater(this.prevState);
-      } else {
-        this.state = updater;
-      }
-    }
-    (_c = (_b = this.options) == null ? void 0 : _b.onUpdate) == null ? void 0 : _c.call(_b);
-    __flush(this);
-  }
-}class Derived {
-  constructor(options) {
-    this.listeners = /* @__PURE__ */new Set();
-    this._subscriptions = [];
-    this.lastSeenDepValues = [];
-    this.getDepVals = () => {
-      const l = this.options.deps.length;
-      const prevDepVals = new Array(l);
-      const currDepVals = new Array(l);
-      for (let i = 0; i < l; i++) {
-        const dep = this.options.deps[i];
-        prevDepVals[i] = dep.prevState;
-        currDepVals[i] = dep.state;
-      }
-      this.lastSeenDepValues = currDepVals;
-      return {
-        prevDepVals,
-        currDepVals,
-        prevVal: this.prevState ?? void 0
-      };
-    };
-    this.recompute = () => {
-      var _a, _b;
-      this.prevState = this.state;
-      const depVals = this.getDepVals();
-      this.state = this.options.fn(depVals);
-      (_b = (_a = this.options).onUpdate) == null ? void 0 : _b.call(_a);
-    };
-    this.checkIfRecalculationNeededDeeply = () => {
-      for (const dep of this.options.deps) {
-        if (dep instanceof Derived) {
-          dep.checkIfRecalculationNeededDeeply();
-        }
-      }
-      let shouldRecompute = false;
-      const lastSeenDepValues = this.lastSeenDepValues;
-      const {
-        currDepVals
-      } = this.getDepVals();
-      for (let i = 0; i < currDepVals.length; i++) {
-        if (currDepVals[i] !== lastSeenDepValues[i]) {
-          shouldRecompute = true;
-          break;
-        }
-      }
-      if (shouldRecompute) {
-        this.recompute();
-      }
-    };
-    this.mount = () => {
-      this.registerOnGraph();
-      this.checkIfRecalculationNeededDeeply();
-      return () => {
-        this.unregisterFromGraph();
-        for (const cleanup of this._subscriptions) {
-          cleanup();
-        }
-      };
-    };
-    this.subscribe = listener => {
-      var _a, _b;
-      this.listeners.add(listener);
-      const unsub = (_b = (_a = this.options).onSubscribe) == null ? void 0 : _b.call(_a, listener, this);
-      return () => {
-        this.listeners.delete(listener);
-        unsub == null ? void 0 : unsub();
-      };
-    };
-    this.options = options;
-    this.state = options.fn({
-      prevDepVals: void 0,
-      prevVal: void 0,
-      currDepVals: this.getDepVals().currDepVals
-    });
-  }
-  registerOnGraph(deps = this.options.deps) {
-    for (const dep of deps) {
-      if (dep instanceof Derived) {
-        dep.registerOnGraph();
-        this.registerOnGraph(dep.options.deps);
-      } else if (dep instanceof Store) {
-        let relatedLinkedDerivedVals = __storeToDerived.get(dep);
-        if (!relatedLinkedDerivedVals) {
-          relatedLinkedDerivedVals = /* @__PURE__ */new Set();
-          __storeToDerived.set(dep, relatedLinkedDerivedVals);
-        }
-        relatedLinkedDerivedVals.add(this);
-        let relatedStores = __derivedToStore.get(this);
-        if (!relatedStores) {
-          relatedStores = /* @__PURE__ */new Set();
-          __derivedToStore.set(this, relatedStores);
-        }
-        relatedStores.add(dep);
-      }
-    }
-  }
-  unregisterFromGraph(deps = this.options.deps) {
-    for (const dep of deps) {
-      if (dep instanceof Derived) {
-        this.unregisterFromGraph(dep.options.deps);
-      } else if (dep instanceof Store) {
-        const relatedLinkedDerivedVals = __storeToDerived.get(dep);
-        if (relatedLinkedDerivedVals) {
-          relatedLinkedDerivedVals.delete(this);
-        }
-        const relatedStores = __derivedToStore.get(this);
-        if (relatedStores) {
-          relatedStores.delete(dep);
+    minSizeToCompress = 1024,
+    deflateLevel = 1,
+    writeDebounceMs = 50
+  } = options;
+  const pendingWrites = new Map();
+  let flushTimer;
+  let lifecycleHooksInstalled = false;
+  const flush = () => {
+    flushTimer = undefined;
+    for (const [key, value] of pendingWrites) {
+      try {
+        if (value.length < minSizeToCompress) {
+          base.setItem(key, RAW_PREFIX + value);
+          continue;
         }
-      }
-    }
-  }
-}//#region src/lite-throttler.ts
-/**
-* A lightweight class that creates a throttled function.
-*
-* This is an alternative to the Throttler in the core @tanstack/pacer package, but is more
-* suitable for libraries and npm packages that need minimal overhead. Unlike the core Throttler,
-* this version does not use TanStack Store for state management, has no devtools integration,
-* and provides only essential throttling functionality.
-*
-* Throttling ensures a function is called at most once within a specified time window.
-* Unlike debouncing which waits for a pause in calls, throttling guarantees consistent
-* execution timing regardless of call frequency.
-*
-* Supports both leading and trailing edge execution:
-* - Leading: Execute immediately on first call (default: true)
-* - Trailing: Execute after wait period if called during throttle (default: true)
-*
-* Features:
-* - Zero dependencies - no external libraries required
-* - Minimal API surface - only essential methods (maybeExecute, flush, cancel)
-* - Simple state management - uses basic private properties instead of reactive stores
-* - Callback support for monitoring execution events
-* - Lightweight - designed for use in npm packages where bundle size matters
-*
-* @example
-* ```ts
-* const throttler = new LiteThrottler((scrollY: number) => {
-*   updateScrollPosition(scrollY);
-* }, {
-*   wait: 100,
-*   onExecute: (args, throttler) => {
-*     console.log('Updated scroll position:', args[0]);
-*   }
-* });
-*
-* // Will execute at most once per 100ms
-* window.addEventListener('scroll', () => {
-*   throttler.maybeExecute(window.scrollY);
-* });
-* ```
-*/
-var LiteThrottler = class {
-  constructor(fn, options) {
-    this.fn = fn;
-    this.options = options;
-    this.lastExecutionTime = 0;
-    this.isPending = false;
-    this.maybeExecute = (...args) => {
-      const timeSinceLastExecution = Date.now() - this.lastExecutionTime;
-      if (this.options.leading && timeSinceLastExecution >= this.options.wait) this.execute(...args);else {
-        this.lastArgs = args;
-        if (!this.timeoutId && this.options.trailing) {
-          const timeoutDuration = this.options.wait - timeSinceLastExecution;
-          this.isPending = true;
-          this.timeoutId = setTimeout(() => {
-            if (this.lastArgs !== void 0) this.execute(...this.lastArgs);
-          }, timeoutDuration);
+        const input = strToU8(value);
+        const compressed = deflateSync(input, {
+          level: deflateLevel
+        });
+        base.setItem(key, DEFLATE_PREFIX + u8ToBase64(compressed));
+      } catch (error) {
+        console.error('Error setting item:', error);
+        try {
+          base.setItem(key, RAW_PREFIX + value);
+        } catch (_a) {
+          // ignore
         }
       }
-    };
-    this.execute = (...args) => {
-      this.fn(...args);
-      this.options.onExecute?.(args, this);
-      this.lastExecutionTime = Date.now();
-      this.clearTimeout();
-      this.lastArgs = void 0;
-      this.isPending = false;
-    };
-    this.flush = () => {
-      if (this.isPending && this.lastArgs) this.execute(...this.lastArgs);
-    };
-    this.cancel = () => {
-      this.clearTimeout();
-      this.lastArgs = void 0;
-      this.isPending = false;
-    };
-    this.clearTimeout = () => {
-      if (this.timeoutId) {
-        clearTimeout(this.timeoutId);
-        this.timeoutId = void 0;
-      }
-    };
-    if (this.options.leading === void 0 && this.options.trailing === void 0) {
-      this.options.leading = true;
-      this.options.trailing = true;
-    }
-  }
-};
-/**
-* Creates a lightweight throttled function that limits how often the provided function can execute.
-*
-* This is an alternative to the throttle function in the core @tanstack/pacer package, but is more
-* suitable for libraries and npm packages that need minimal overhead. Unlike the core version,
-* this function creates a throttler with no external dependencies, devtools integration, or reactive state.
-*
-* Throttling ensures a function executes at most once within a specified time window,
-* regardless of how many times it is called. This is useful for rate-limiting
-* expensive operations or UI updates.
-*
-* @example
-* ```ts
-* const throttledScroll = liteThrottle(() => {
-*   updateScrollIndicator();
-* }, { wait: 100 });
-*
-* // Will execute at most once per 100ms
-* window.addEventListener('scroll', throttledScroll);
-* ```
-*
-* @example
-* ```ts
-* // Leading edge execution - fires immediately then throttles
-* const throttledResize = liteThrottle(() => {
-*   recalculateLayout();
-* }, { wait: 250, leading: true, trailing: false });
-* ```
-*/
-function liteThrottle(fn, options) {
-  return new LiteThrottler(fn, options).maybeExecute;
-}class EventClient {
-  #enabled = true;
-  #pluginId;
-  #eventTarget;
-  #debug;
-  #queuedEvents;
-  #connected;
-  #connectIntervalId;
-  #connectEveryMs;
-  #retryCount = 0;
-  #maxRetries = 5;
-  #connecting = false;
-  #failedToConnect = false;
-  #internalEventTarget = null;
-  #onConnected = () => {
-    this.debugLog("Connected to event bus");
-    this.#connected = true;
-    this.#connecting = false;
-    this.debugLog("Emitting queued events", this.#queuedEvents);
-    this.#queuedEvents.forEach(event => this.emitEventToBus(event));
-    this.#queuedEvents = [];
-    this.stopConnectLoop();
-    this.#eventTarget().removeEventListener("tanstack-connect-success", this.#onConnected);
-  };
-  // fired off right away and then at intervals
-  #retryConnection = () => {
-    if (this.#retryCount < this.#maxRetries) {
-      this.#retryCount++;
-      this.dispatchCustomEvent("tanstack-connect", {});
-      return;
     }
-    this.#eventTarget().removeEventListener("tanstack-connect", this.#retryConnection);
-    this.#failedToConnect = true;
-    this.debugLog("Max retries reached, giving up on connection");
-    this.stopConnectLoop();
-  };
-  // This is run to register connection handlers on first emit attempt
-  #connectFunction = () => {
-    if (this.#connecting) return;
-    this.#connecting = true;
-    this.#eventTarget().addEventListener("tanstack-connect-success", this.#onConnected);
-    this.#retryConnection();
+    pendingWrites.clear();
   };
-  constructor({
-    pluginId,
-    debug = false,
-    enabled = true,
-    reconnectEveryMs = 300
-  }) {
-    this.#pluginId = pluginId;
-    this.#enabled = enabled;
-    this.#eventTarget = this.getGlobalTarget;
-    this.#debug = debug;
-    this.debugLog(" Initializing event subscription for plugin", this.#pluginId);
-    this.#queuedEvents = [];
-    this.#connected = false;
-    this.#failedToConnect = false;
-    this.#connectIntervalId = null;
-    this.#connectEveryMs = reconnectEveryMs;
-  }
-  startConnectLoop() {
-    if (this.#connectIntervalId !== null || this.#connected) return;
-    this.debugLog(`Starting connect loop (every ${this.#connectEveryMs}ms)`);
-    this.#connectIntervalId = setInterval(this.#retryConnection, this.#connectEveryMs);
-  }
-  stopConnectLoop() {
-    this.#connecting = false;
-    if (this.#connectIntervalId === null) {
-      return;
-    }
-    clearInterval(this.#connectIntervalId);
-    this.#connectIntervalId = null;
-    this.#queuedEvents = [];
-    this.debugLog("Stopped connect loop");
-  }
-  debugLog(...args) {
-    if (this.#debug) {
-      console.log(`🌴 [tanstack-devtools:${this.#pluginId}-plugin]`, ...args);
-    }
-  }
-  getGlobalTarget() {
-    if (typeof globalThis !== "undefined" && globalThis.__TANSTACK_EVENT_TARGET__) {
-      this.debugLog("Using global event target");
-      return globalThis.__TANSTACK_EVENT_TARGET__;
-    }
-    if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
-      this.debugLog("Using window as event target");
-      return window;
-    }
-    const eventTarget = typeof EventTarget !== "undefined" ? new EventTarget() : void 0;
-    if (typeof eventTarget === "undefined" || typeof eventTarget.addEventListener === "undefined") {
-      this.debugLog("No event mechanism available, running in non-web environment");
-      return {
-        addEventListener: () => {},
-        removeEventListener: () => {},
-        dispatchEvent: () => false
-      };
-    }
-    this.debugLog("Using new EventTarget as fallback");
-    return eventTarget;
-  }
-  getPluginId() {
-    return this.#pluginId;
-  }
-  dispatchCustomEventShim(eventName, detail) {
-    try {
-      const event = new Event(eventName, {
-        detail
+  const scheduleFlush = () => {
+    if (flushTimer != null) return;
+    if (!lifecycleHooksInstalled && typeof window !== 'undefined') {
+      lifecycleHooksInstalled = true;
+      window.addEventListener('beforeunload', flush);
+      document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') flush();
       });
-      this.#eventTarget().dispatchEvent(event);
-    } catch (e) {
-      this.debugLog("Failed to dispatch shim event");
-    }
-  }
-  dispatchCustomEvent(eventName, detail) {
-    try {
-      this.#eventTarget().dispatchEvent(new CustomEvent(eventName, {
-        detail
-      }));
-    } catch (e) {
-      this.dispatchCustomEventShim(eventName, detail);
-    }
-  }
-  emitEventToBus(event) {
-    this.debugLog("Emitting event to client bus", event);
-    this.dispatchCustomEvent("tanstack-dispatch-event", event);
-  }
-  createEventPayload(eventSuffix, payload) {
-    return {
-      type: `${this.#pluginId}:${eventSuffix}`,
-      payload,
-      pluginId: this.#pluginId
-    };
-  }
-  emit(eventSuffix, payload) {
-    if (!this.#enabled) {
-      this.debugLog("Event bus client is disabled, not emitting event", eventSuffix, payload);
-      return;
     }
-    if (this.#internalEventTarget) {
-      this.debugLog("Emitting event to internal event target", eventSuffix, payload);
-      this.#internalEventTarget.dispatchEvent(new CustomEvent(`${this.#pluginId}:${eventSuffix}`, {
-        detail: this.createEventPayload(eventSuffix, payload)
-      }));
-    }
-    if (this.#failedToConnect) {
-      this.debugLog("Previously failed to connect, not emitting to bus");
-      return;
-    }
-    if (!this.#connected) {
-      this.debugLog("Bus not available, will be pushed as soon as connected");
-      this.#queuedEvents.push(this.createEventPayload(eventSuffix, payload));
-      if (typeof CustomEvent !== "undefined" && !this.#connecting) {
-        this.#connectFunction();
-        this.startConnectLoop();
+    flushTimer = globalThis.setTimeout(flush, writeDebounceMs);
+  };
+  return {
+    getItem: key => {
+      try {
+        const stored = base.getItem(key);
+        if (!stored) return null;
+        if (stored.startsWith(RAW_PREFIX)) {
+          return stored.slice(RAW_PREFIX.length);
+        }
+        if (stored.startsWith(DEFLATE_PREFIX)) {
+          const b64 = stored.slice(DEFLATE_PREFIX.length);
+          const bytes = base64ToU8(b64);
+          const decompressed = inflateSync(bytes);
+          return strFromU8(decompressed);
+        }
+        // Back-compat: older versions may have stored raw JSON without any prefix
+        if (isProbablyJson(stored)) return stored;
+        return null;
+      } catch (error) {
+        console.error('Error getting item:', error);
+        return null;
       }
-      return;
-    }
-    return this.emitEventToBus(this.createEventPayload(eventSuffix, payload));
-  }
-  on(eventSuffix, cb, options) {
-    const withEventTarget = options?.withEventTarget ?? false;
-    const eventName = `${this.#pluginId}:${eventSuffix}`;
-    if (withEventTarget) {
-      if (!this.#internalEventTarget) {
-        this.#internalEventTarget = new EventTarget();
+    },
+    setItem: (key, value) => {
+      try {
+        // Some upstream serializers can return `undefined` (e.g. JSON.stringify(undefined)).
+        const rawValue = value;
+        if (rawValue == null) {
+          pendingWrites.delete(key);
+          base.removeItem(key);
+          return;
+        }
+        const stringValue = typeof rawValue === 'string' ? rawValue : String(rawValue);
+        pendingWrites.set(key, stringValue);
+        scheduleFlush();
+      } catch (error) {
+        console.error('Error setting item:', error);
       }
-      this.#internalEventTarget.addEventListener(eventName, e => {
-        cb(e.detail);
-      });
-    }
-    if (!this.#enabled) {
-      this.debugLog("Event bus client is disabled, not registering event", eventName);
-      return () => {};
-    }
-    const handler = e => {
-      this.debugLog("Received event from bus", e.detail);
-      cb(e.detail);
-    };
-    this.#eventTarget().addEventListener(eventName, handler);
-    this.debugLog("Registered event to bus", eventName);
-    return () => {
-      if (withEventTarget) {
-        this.#internalEventTarget?.removeEventListener(eventName, handler);
+    },
+    removeItem: key => {
+      try {
+        pendingWrites.delete(key);
+        base.removeItem(key);
+      } catch (error) {
+        console.error('Error removing item:', error);
       }
-      this.#eventTarget().removeEventListener(eventName, handler);
-    };
-  }
-  onAll(cb) {
-    if (!this.#enabled) {
-      this.debugLog("Event bus client is disabled, not registering event");
-      return () => {};
     }
-    const handler = e => {
-      const event = e.detail;
-      cb(event);
-    };
-    this.#eventTarget().addEventListener("tanstack-devtools-global", handler);
-    return () => this.#eventTarget().removeEventListener("tanstack-devtools-global", handler);
-  }
-  onAllPluginEvents(cb) {
-    if (!this.#enabled) {
-      this.debugLog("Event bus client is disabled, not registering event");
-      return () => {};
-    }
-    const handler = e => {
-      const event = e.detail;
-      if (this.#pluginId && event.pluginId !== this.#pluginId) {
-        return;
-      }
-      cb(event);
-    };
-    this.#eventTarget().addEventListener("tanstack-devtools-global", handler);
-    return () => this.#eventTarget().removeEventListener("tanstack-devtools-global", handler);
-  }
-}class FormEventClient extends EventClient {
-  constructor() {
-    super({
-      pluginId: "form-devtools",
-      reconnectEveryMs: 1e3
-    });
+  };
+};
+const baseStorage = {
+  getItem: key => {
+    if (typeof localStorage === 'undefined') return null;
+    return localStorage.getItem(key);
+  },
+  setItem: (key, value) => {
+    if (typeof localStorage === 'undefined') return;
+    localStorage.setItem(key, value);
+  },
+  removeItem: key => {
+    if (typeof localStorage === 'undefined') return;
+    localStorage.removeItem(key);
   }
-}
-const formEventClient = new FormEventClient();function functionalUpdate(updater, input) {
-  return typeof updater === "function" ? updater(input) : updater;
-}
-function getBy(obj, path) {
-  const pathObj = makePathArray(path);
-  return pathObj.reduce((current, pathPart) => {
-    if (current === null) return null;
-    if (typeof current !== "undefined") {
-      return current[pathPart];
-    }
-    return void 0;
-  }, obj);
-}
-function setBy(obj, _path, updater) {
-  const path = makePathArray(_path);
-  function doSet(parent) {
-    if (!path.length) {
-      return functionalUpdate(updater, parent);
+};
+let storage = createCompressedStorage(baseStorage);// Implementazione
+function atomStateGenerator({
+  key,
+  defaultValue,
+  persist = false,
+  storage: customStorage
+}) {
+  const resolvedStorage = customStorage || storage;
+  // Usa atomWithStorage solo se persist è true, altrimenti atom normale
+  const jotaiAtom = persist ? atomWithStorage(key, defaultValue, createJSONStorage(() => resolvedStorage)) : atom(defaultValue);
+  const useValue = () => {
+    const [value] = useAtom(jotaiAtom);
+    return value;
+  };
+  const useState = () => {
+    const $ = c(3);
+    const [value, setValue] = useAtom(jotaiAtom);
+    let t0;
+    if ($[0] !== setValue || $[1] !== value) {
+      t0 = [value, setValue];
+      $[0] = setValue;
+      $[1] = value;
+      $[2] = t0;
+    } else {
+      t0 = $[2];
     }
-    const key = path.shift();
-    if (typeof key === "string" || typeof key === "number" && !Array.isArray(parent)) {
-      if (typeof parent === "object") {
-        if (parent === null) {
-          parent = {};
+    return t0;
+  };
+  const useReset = () => {
+    const $ = c(2);
+    const [, setValue] = useAtom(jotaiAtom);
+    let t0;
+    if ($[0] !== setValue) {
+      t0 = () => {
+        setValue(defaultValue);
+        if (persist) {
+          resolvedStorage.removeItem(key);
         }
-        return {
-          ...parent,
-          [key]: doSet(parent[key])
-        };
-      }
-      return {
-        [key]: doSet()
       };
+      $[0] = setValue;
+      $[1] = t0;
+    } else {
+      t0 = $[1];
     }
-    if (Array.isArray(parent) && typeof key === "number") {
-      const prefix = parent.slice(0, key);
-      return [...(prefix.length ? prefix : new Array(key)), doSet(parent[key]), ...parent.slice(key + 1)];
-    }
-    return [...new Array(key), doSet()];
-  }
-  return doSet(obj);
-}
-function deleteBy(obj, _path) {
-  const path = makePathArray(_path);
-  function doDelete(parent) {
-    if (!parent) return;
-    if (path.length === 1) {
-      const finalPath = path[0];
-      if (Array.isArray(parent) && typeof finalPath === "number") {
-        return parent.filter((_, i) => i !== finalPath);
-      }
-      const {
-        [finalPath]: remove,
-        ...rest
-      } = parent;
-      return rest;
-    }
-    const key = path.shift();
-    if (typeof key === "string" || typeof key === "number" && !Array.isArray(parent)) {
-      if (typeof parent === "object") {
-        return {
-          ...parent,
-          [key]: doDelete(parent[key])
-        };
-      }
-    }
-    if (typeof key === "number") {
-      if (Array.isArray(parent)) {
-        if (key >= parent.length) {
-          return parent;
-        }
-        const prefix = parent.slice(0, key);
-        return [...(prefix.length ? prefix : new Array(key)), doDelete(parent[key]), ...parent.slice(key + 1)];
-      }
-    }
-    throw new Error("It seems we have created an infinite loop in deleteBy. ");
-  }
-  return doDelete(obj);
-}
-const reLineOfOnlyDigits = /^(\d+)$/gm;
-const reDigitsBetweenDots = /\.(\d+)(?=\.)/gm;
-const reStartWithDigitThenDot = /^(\d+)\./gm;
-const reDotWithDigitsToEnd = /\.(\d+$)/gm;
-const reMultipleDots = /\.{2,}/gm;
-const intPrefix = "__int__";
-const intReplace = `${intPrefix}$1`;
-function makePathArray(str) {
-  if (Array.isArray(str)) {
-    return [...str];
-  }
-  if (typeof str !== "string") {
-    throw new Error("Path must be a string.");
-  }
-  return str.replace(/(^\[)|]/gm, "").replace(/\[/g, ".").replace(reLineOfOnlyDigits, intReplace).replace(reDigitsBetweenDots, `.${intReplace}.`).replace(reStartWithDigitThenDot, `${intReplace}.`).replace(reDotWithDigitsToEnd, `.${intReplace}`).replace(reMultipleDots, ".").split(".").map(d => {
-    if (d.startsWith(intPrefix)) {
-      const numStr = d.substring(intPrefix.length);
-      const num = parseInt(numStr, 10);
-      if (String(num) === numStr) {
-        return num;
-      }
-      return numStr;
-    }
-    return d;
-  });
-}
-function isNonEmptyArray(obj) {
-  return !(Array.isArray(obj) && obj.length === 0);
-}
-function getSyncValidatorArray(cause, options) {
-  const runValidation = props => {
-    return props.validators.filter(Boolean).map(validator => {
-      return {
-        cause: validator.cause,
-        validate: validator.fn
-      };
-    });
-  };
-  return options.validationLogic({
-    form: options.form,
-    validators: options.validators,
-    event: {
-      type: cause,
-      async: false
-    },
-    runValidation
-  });
-}
-function getAsyncValidatorArray(cause, options) {
-  const {
-    asyncDebounceMs
-  } = options;
-  const {
-    onBlurAsyncDebounceMs,
-    onChangeAsyncDebounceMs,
-    onDynamicAsyncDebounceMs
-  } = options.validators || {};
-  const defaultDebounceMs = asyncDebounceMs ?? 0;
-  const runValidation = props => {
-    return props.validators.filter(Boolean).map(validator => {
-      const validatorCause = validator?.cause || cause;
-      let debounceMs = defaultDebounceMs;
-      switch (validatorCause) {
-        case "change":
-          debounceMs = onChangeAsyncDebounceMs ?? defaultDebounceMs;
-          break;
-        case "blur":
-          debounceMs = onBlurAsyncDebounceMs ?? defaultDebounceMs;
-          break;
-        case "dynamic":
-          debounceMs = onDynamicAsyncDebounceMs ?? defaultDebounceMs;
-          break;
-        case "submit":
-          debounceMs = 0;
-          break;
-      }
-      if (cause === "submit") {
-        debounceMs = 0;
-      }
-      return {
-        cause: validatorCause,
-        validate: validator.fn,
-        debounceMs
-      };
-    });
+    return t0;
   };
-  return options.validationLogic({
-    form: options.form,
-    validators: options.validators,
-    event: {
-      type: cause,
-      async: true
-    },
-    runValidation
-  });
-}
-const isGlobalFormValidationError = error => {
-  return !!error && typeof error === "object" && "fields" in error;
-};
-function evaluate(objA, objB) {
-  if (Object.is(objA, objB)) {
-    return true;
-  }
-  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
-    return false;
-  }
-  if (objA instanceof Date && objB instanceof Date) {
-    return objA.getTime() === objB.getTime();
-  }
-  if (objA instanceof Map && objB instanceof Map) {
-    if (objA.size !== objB.size) return false;
-    for (const [k, v] of objA) {
-      if (!objB.has(k) || !Object.is(v, objB.get(k))) return false;
-    }
-    return true;
-  }
-  if (objA instanceof Set && objB instanceof Set) {
-    if (objA.size !== objB.size) return false;
-    for (const v of objA) {
-      if (!objB.has(v)) return false;
-    }
-    return true;
-  }
-  const keysA = Object.keys(objA);
-  const keysB = Object.keys(objB);
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-  for (const key of keysA) {
-    if (!keysB.includes(key) || !evaluate(objA[key], objB[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-const determineFormLevelErrorSourceAndValue = ({
-  newFormValidatorError,
-  isPreviousErrorFromFormValidator,
-  previousErrorValue
-}) => {
-  if (newFormValidatorError) {
-    return {
-      newErrorValue: newFormValidatorError,
-      newSource: "form"
-    };
-  }
-  if (isPreviousErrorFromFormValidator) {
-    return {
-      newErrorValue: void 0,
-      newSource: void 0
-    };
-  }
-  if (previousErrorValue) {
-    return {
-      newErrorValue: previousErrorValue,
-      newSource: "field"
-    };
-  }
   return {
-    newErrorValue: void 0,
-    newSource: void 0
+    atom: jotaiAtom,
+    useValue,
+    useState,
+    useReset
   };
-};
-const determineFieldLevelErrorSourceAndValue = ({
-  formLevelError,
-  fieldLevelError
+}const DefaultContainer$1 = ({
+  children
 }) => {
-  if (fieldLevelError) {
-    return {
-      newErrorValue: fieldLevelError,
-      newSource: "field"
-    };
-  }
-  if (formLevelError) {
-    return {
-      newErrorValue: formLevelError,
-      newSource: "form"
-    };
-  }
-  return {
-    newErrorValue: void 0,
-    newSource: void 0
-  };
-};
-function mergeOpts(originalOpts, overrides) {
-  if (originalOpts === void 0 || originalOpts === null) {
-    return overrides;
-  }
-  return {
-    ...originalOpts,
-    ...overrides
-  };
-}
-let IDX = 256;
-const HEX = [];
-let BUFFER;
-while (IDX--) {
-  HEX[IDX] = (IDX + 256).toString(16).substring(1);
-}
-function uuid() {
-  let i = 0;
-  let num;
-  let out = "";
-  if (!BUFFER || IDX + 16 > 256) {
-    BUFFER = new Array(256);
-    i = 256;
-    while (i--) {
-      BUFFER[i] = 256 * Math.random() | 0;
-    }
-    i = 0;
-    IDX = 0;
-  }
-  for (; i < 16; i++) {
-    num = BUFFER[IDX + i];
-    if (i === 6) out += HEX[num & 15 | 64];else if (i === 8) out += HEX[num & 63 | 128];else out += HEX[num];
-    if (i & 1 && i > 1 && i < 11) out += "-";
-  }
-  IDX++;
-  return out;
-}
-const throttleFormState = liteThrottle(form => formEventClient.emit("form-state", {
-  id: form.formId,
-  state: form.store.state
-}), {
-  wait: 300
-});const defaultValidationLogic = props => {
-  if (!props.validators) {
-    return props.runValidation({
-      validators: [],
-      form: props.form
-    });
-  }
-  const isAsync = props.event.async;
-  const onMountValidator = isAsync ? void 0 : {
-    fn: props.validators.onMount,
-    cause: "mount"
-  };
-  const onChangeValidator = {
-    fn: isAsync ? props.validators.onChangeAsync : props.validators.onChange,
-    cause: "change"
-  };
-  const onBlurValidator = {
-    fn: isAsync ? props.validators.onBlurAsync : props.validators.onBlur,
-    cause: "blur"
-  };
-  const onSubmitValidator = {
-    fn: isAsync ? props.validators.onSubmitAsync : props.validators.onSubmit,
-    cause: "submit"
-  };
-  const onServerValidator = isAsync ? void 0 : {
-    fn: () => void 0,
-    cause: "server"
-  };
-  switch (props.event.type) {
-    case "mount":
-      {
-        return props.runValidation({
-          validators: [onMountValidator],
-          form: props.form
-        });
-      }
-    case "submit":
-      {
-        return props.runValidation({
-          validators: [onChangeValidator, onBlurValidator, onSubmitValidator, onServerValidator],
-          form: props.form
-        });
-      }
-    case "server":
-      {
-        return props.runValidation({
-          validators: [],
-          form: props.form
-        });
-      }
-    case "blur":
-      {
-        return props.runValidation({
-          validators: [onBlurValidator, onServerValidator],
-          form: props.form
-        });
-      }
-    case "change":
-      {
-        return props.runValidation({
-          validators: [onChangeValidator, onServerValidator],
-          form: props.form
-        });
-      }
-    default:
-      {
-        throw new Error(`Unknown validation event type: ${props.event.type}`);
-      }
-  }
-};function prefixSchemaToErrors(issues, formValue) {
-  const schema = /* @__PURE__ */new Map();
-  for (const issue of issues) {
-    const issuePath = issue.path ?? [];
-    let currentFormValue = formValue;
-    let path = "";
-    for (let i = 0; i < issuePath.length; i++) {
-      const pathSegment = issuePath[i];
-      if (pathSegment === void 0) continue;
-      const segment = typeof pathSegment === "object" ? pathSegment.key : pathSegment;
-      const segmentAsNumber = Number(segment);
-      if (Array.isArray(currentFormValue) && !Number.isNaN(segmentAsNumber)) {
-        path += `[${segmentAsNumber}]`;
-      } else {
-        path += (i > 0 ? "." : "") + String(segment);
-      }
-      if (typeof currentFormValue === "object" && currentFormValue !== null) {
-        currentFormValue = currentFormValue[segment];
-      } else {
-        currentFormValue = void 0;
-      }
-    }
-    schema.set(path, (schema.get(path) ?? []).concat(issue));
-  }
-  return Object.fromEntries(schema);
-}
-const transformFormIssues = (issues, formValue) => {
-  const schemaErrors = prefixSchemaToErrors(issues, formValue);
-  return {
-    form: schemaErrors,
-    fields: schemaErrors
-  };
-};
-const standardSchemaValidators = {
-  validate({
-    value,
-    validationSource
-  }, schema) {
-    const result = schema["~standard"].validate(value);
-    if (result instanceof Promise) {
-      throw new Error("async function passed to sync validator");
-    }
-    if (!result.issues) return;
-    if (validationSource === "field") return result.issues;
-    return transformFormIssues(result.issues, value);
-  },
-  async validateAsync({
-    value,
-    validationSource
-  }, schema) {
-    const result = await schema["~standard"].validate(value);
-    if (!result.issues) return;
-    if (validationSource === "field") return result.issues;
-    return transformFormIssues(result.issues, value);
-  }
+  return children;
 };
-const isStandardSchemaValidator = validator => !!validator && "~standard" in validator;const defaultFieldMeta = {
-  isValidating: false,
-  isTouched: false,
-  isBlurred: false,
-  isDirty: false,
-  isPristine: true,
-  isValid: true,
-  isDefaultValue: true,
-  errors: [],
-  errorMap: {},
-  errorSourceMap: {}
+// Lazy initialization to avoid side effects at module load time
+const _formConfig = {
+  formFieldContainer: DefaultContainer$1
 };
-function metaHelper(formApi) {
-  function handleArrayMove(field, fromIndex, toIndex) {
-    const affectedFields = getAffectedFields(field, fromIndex, "move", toIndex);
-    const startIndex = Math.min(fromIndex, toIndex);
-    const endIndex = Math.max(fromIndex, toIndex);
-    for (let i = startIndex; i <= endIndex; i++) {
-      affectedFields.push(getFieldPath(field, i));
-    }
-    const fromFields = Object.keys(formApi.fieldInfo).reduce((fieldMap, fieldKey) => {
-      if (fieldKey.startsWith(getFieldPath(field, fromIndex))) {
-        fieldMap.set(fieldKey, formApi.getFieldMeta(fieldKey));
-      }
-      return fieldMap;
-    }, /* @__PURE__ */new Map());
-    shiftMeta(affectedFields, fromIndex < toIndex ? "up" : "down");
-    Object.keys(formApi.fieldInfo).filter(fieldKey => fieldKey.startsWith(getFieldPath(field, toIndex))).forEach(fieldKey => {
-      const fromKey = fieldKey.replace(getFieldPath(field, toIndex), getFieldPath(field, fromIndex));
-      const fromMeta = fromFields.get(fromKey);
-      if (fromMeta) {
-        formApi.setFieldMeta(fieldKey, fromMeta);
-      }
-    });
-  }
-  function handleArrayRemove(field, index) {
-    const affectedFields = getAffectedFields(field, index, "remove");
-    shiftMeta(affectedFields, "up");
-  }
-  function handleArraySwap(field, index, secondIndex) {
-    const affectedFields = getAffectedFields(field, index, "swap", secondIndex);
-    affectedFields.forEach(fieldKey => {
-      if (!fieldKey.toString().startsWith(getFieldPath(field, index))) {
-        return;
-      }
-      const swappedKey = fieldKey.toString().replace(getFieldPath(field, index), getFieldPath(field, secondIndex));
-      const [meta1, meta2] = [formApi.getFieldMeta(fieldKey), formApi.getFieldMeta(swappedKey)];
-      if (meta1) formApi.setFieldMeta(swappedKey, meta1);
-      if (meta2) formApi.setFieldMeta(fieldKey, meta2);
-    });
-  }
-  function handleArrayInsert(field, insertIndex) {
-    const affectedFields = getAffectedFields(field, insertIndex, "insert");
-    shiftMeta(affectedFields, "down");
-    affectedFields.forEach(fieldKey => {
-      if (fieldKey.toString().startsWith(getFieldPath(field, insertIndex))) {
-        formApi.setFieldMeta(fieldKey, getEmptyFieldMeta());
-      }
-    });
-  }
-  function getFieldPath(field, index) {
-    return `${field}[${index}]`;
-  }
-  function getAffectedFields(field, index, mode, secondIndex) {
-    const affectedFieldKeys = [getFieldPath(field, index)];
-    switch (mode) {
-      case "swap":
-        affectedFieldKeys.push(getFieldPath(field, secondIndex));
-        break;
-      case "move":
-        {
-          const [startIndex, endIndex] = [Math.min(index, secondIndex), Math.max(index, secondIndex)];
-          for (let i = startIndex; i <= endIndex; i++) {
-            affectedFieldKeys.push(getFieldPath(field, i));
-          }
-          break;
-        }
-      default:
-        {
-          const currentValue = formApi.getFieldValue(field);
-          const fieldItems = Array.isArray(currentValue) ? currentValue.length : 0;
-          for (let i = index + 1; i < fieldItems; i++) {
-            affectedFieldKeys.push(getFieldPath(field, i));
-          }
-          break;
-        }
-    }
-    return Object.keys(formApi.fieldInfo).filter(fieldKey => affectedFieldKeys.some(key => fieldKey.startsWith(key)));
-  }
-  function updateIndex(fieldKey, direction) {
-    return fieldKey.replace(/\[(\d+)\]/, (_, num) => {
-      const currIndex = parseInt(num, 10);
-      const newIndex = direction === "up" ? currIndex + 1 : Math.max(0, currIndex - 1);
-      return `[${newIndex}]`;
-    });
-  }
-  function shiftMeta(fields, direction) {
-    const sortedFields = direction === "up" ? fields : [...fields].reverse();
-    sortedFields.forEach(fieldKey => {
-      const nextFieldKey = updateIndex(fieldKey.toString(), direction);
-      const nextFieldMeta = formApi.getFieldMeta(nextFieldKey);
-      if (nextFieldMeta) {
-        formApi.setFieldMeta(fieldKey, nextFieldMeta);
-      } else {
-        formApi.setFieldMeta(fieldKey, getEmptyFieldMeta());
-      }
-    });
-  }
-  const getEmptyFieldMeta = () => defaultFieldMeta;
-  return {
-    handleArrayMove,
-    handleArrayRemove,
-    handleArraySwap,
-    handleArrayInsert
-  };
-}function getDefaultFormState(defaultState) {
-  return {
-    values: defaultState.values ?? {},
-    errorMap: defaultState.errorMap ?? {},
-    fieldMetaBase: defaultState.fieldMetaBase ?? {},
-    isSubmitted: defaultState.isSubmitted ?? false,
-    isSubmitting: defaultState.isSubmitting ?? false,
-    isValidating: defaultState.isValidating ?? false,
-    submissionAttempts: defaultState.submissionAttempts ?? 0,
-    isSubmitSuccessful: defaultState.isSubmitSuccessful ?? false,
-    validationMetaMap: defaultState.validationMetaMap ?? {
-      onChange: void 0,
-      onBlur: void 0,
-      onSubmit: void 0,
-      onMount: void 0,
-      onServer: void 0,
-      onDynamic: void 0
-    }
-  };
-}
-class FormApi {
-  /**
-   * Constructs a new `FormApi` instance with the given form options.
-   */
-  constructor(opts) {
-    this.options = {};
-    this.fieldInfo = {};
-    this.prevTransformArray = [];
-    this.mount = () => {
-      const cleanupFieldMetaDerived = this.fieldMetaDerived.mount();
-      const cleanupStoreDerived = this.store.mount();
-      const cleanupDevtoolBroadcast = this.store.subscribe(() => {
-        throttleFormState(this);
-      });
-      const cleanupFormStateListener = formEventClient.on("request-form-state", e => {
-        if (e.payload.id === this._formId) {
-          formEventClient.emit("form-api", {
-            id: this._formId,
-            state: this.store.state,
-            options: this.options
-          });
-        }
-      });
-      const cleanupFormResetListener = formEventClient.on("request-form-reset", e => {
-        if (e.payload.id === this._formId) {
-          this.reset();
-        }
-      });
-      const cleanupFormForceSubmitListener = formEventClient.on("request-form-force-submit", e => {
-        if (e.payload.id === this._formId) {
-          this._devtoolsSubmissionOverride = true;
-          this.handleSubmit();
-          this._devtoolsSubmissionOverride = false;
-        }
-      });
-      const cleanup = () => {
-        cleanupFormForceSubmitListener();
-        cleanupFormResetListener();
-        cleanupFormStateListener();
-        cleanupDevtoolBroadcast();
-        cleanupFieldMetaDerived();
-        cleanupStoreDerived();
-        formEventClient.emit("form-unmounted", {
-          id: this._formId
-        });
-      };
-      this.options.listeners?.onMount?.({
-        formApi: this
-      });
-      const {
-        onMount
-      } = this.options.validators || {};
-      formEventClient.emit("form-api", {
-        id: this._formId,
-        state: this.store.state,
-        options: this.options
-      });
-      if (!onMount) return cleanup;
-      this.validateSync("mount");
-      return cleanup;
-    };
-    this.update = options => {
-      if (!options) return;
-      const oldOptions = this.options;
-      this.options = options;
-      const shouldUpdateReeval = !!options.transform?.deps?.some((val, i) => val !== this.prevTransformArray[i]);
-      const shouldUpdateValues = options.defaultValues && !evaluate(options.defaultValues, oldOptions.defaultValues) && !this.state.isTouched;
-      const shouldUpdateState = !evaluate(options.defaultState, oldOptions.defaultState) && !this.state.isTouched;
-      if (!shouldUpdateValues && !shouldUpdateState && !shouldUpdateReeval) return;
-      batch(() => {
-        this.baseStore.setState(() => getDefaultFormState(Object.assign({}, this.state, shouldUpdateState ? options.defaultState : {}, shouldUpdateValues ? {
-          values: options.defaultValues
-        } : {}, shouldUpdateReeval ? {
-          _force_re_eval: !this.state._force_re_eval
-        } : {})));
-      });
-      formEventClient.emit("form-api", {
-        id: this._formId,
-        state: this.store.state,
-        options: this.options
-      });
-    };
-    this.reset = (values, opts2) => {
-      const {
-        fieldMeta: currentFieldMeta
-      } = this.state;
-      const fieldMetaBase = this.resetFieldMeta(currentFieldMeta);
-      if (values && !opts2?.keepDefaultValues) {
-        this.options = {
-          ...this.options,
-          defaultValues: values
-        };
-      }
-      this.baseStore.setState(() => getDefaultFormState({
-        ...this.options.defaultState,
-        values: values ?? this.options.defaultValues ?? this.options.defaultState?.values,
-        fieldMetaBase
-      }));
-    };
-    this.validateAllFields = async cause => {
-      const fieldValidationPromises = [];
-      batch(() => {
-        void Object.values(this.fieldInfo).forEach(field => {
-          if (!field.instance) return;
-          const fieldInstance = field.instance;
-          fieldValidationPromises.push(
-          // Remember, `validate` is either a sync operation or a promise
-          Promise.resolve().then(() => fieldInstance.validate(cause, {
-            skipFormValidation: true
-          })));
-          if (!field.instance.state.meta.isTouched) {
-            field.instance.setMeta(prev => ({
-              ...prev,
-              isTouched: true
-            }));
-          }
-        });
-      });
-      const fieldErrorMapMap = await Promise.all(fieldValidationPromises);
-      return fieldErrorMapMap.flat();
-    };
-    this.validateArrayFieldsStartingFrom = async (field, index, cause) => {
-      const currentValue = this.getFieldValue(field);
-      const lastIndex = Array.isArray(currentValue) ? Math.max(currentValue.length - 1, 0) : null;
-      const fieldKeysToValidate = [`${field}[${index}]`];
-      for (let i = index + 1; i <= (lastIndex ?? 0); i++) {
-        fieldKeysToValidate.push(`${field}[${i}]`);
-      }
-      const fieldsToValidate = Object.keys(this.fieldInfo).filter(fieldKey => fieldKeysToValidate.some(key => fieldKey.startsWith(key)));
-      const fieldValidationPromises = [];
-      batch(() => {
-        fieldsToValidate.forEach(nestedField => {
-          fieldValidationPromises.push(Promise.resolve().then(() => this.validateField(nestedField, cause)));
-        });
-      });
-      const fieldErrorMapMap = await Promise.all(fieldValidationPromises);
-      return fieldErrorMapMap.flat();
-    };
-    this.validateField = (field, cause) => {
-      const fieldInstance = this.fieldInfo[field]?.instance;
-      if (!fieldInstance) {
-        const {
-          hasErrored
-        } = this.validateSync(cause);
-        if (hasErrored && !this.options.asyncAlways) {
-          return this.getFieldMeta(field)?.errors ?? [];
-        }
-        return this.validateAsync(cause).then(() => {
-          return this.getFieldMeta(field)?.errors ?? [];
-        });
-      }
-      if (!fieldInstance.state.meta.isTouched) {
-        fieldInstance.setMeta(prev => ({
-          ...prev,
-          isTouched: true
-        }));
-      }
-      return fieldInstance.validate(cause);
-    };
-    this.validateSync = cause => {
-      const validates = getSyncValidatorArray(cause, {
-        ...this.options,
-        form: this,
-        validationLogic: this.options.validationLogic || defaultValidationLogic
-      });
-      let hasErrored = false;
-      const currentValidationErrorMap = {};
-      batch(() => {
-        for (const validateObj of validates) {
-          if (!validateObj.validate) continue;
-          const rawError = this.runValidator({
-            validate: validateObj.validate,
-            value: {
-              value: this.state.values,
-              formApi: this,
-              validationSource: "form"
-            },
-            type: "validate"
-          });
-          const {
-            formError,
-            fieldErrors
-          } = normalizeError$1(rawError);
-          const errorMapKey = getErrorMapKey$1(validateObj.cause);
-          const allFieldsToProcess = /* @__PURE__ */new Set([...Object.keys(this.state.fieldMeta), ...Object.keys(fieldErrors || {})]);
-          for (const field of allFieldsToProcess) {
-            if (this.baseStore.state.fieldMetaBase[field] === void 0 && !fieldErrors?.[field]) {
-              continue;
-            }
-            const fieldMeta = this.getFieldMeta(field) ?? defaultFieldMeta;
-            const {
-              errorMap: currentErrorMap,
-              errorSourceMap: currentErrorMapSource
-            } = fieldMeta;
-            const newFormValidatorError = fieldErrors?.[field];
-            const {
-              newErrorValue,
-              newSource
-            } = determineFormLevelErrorSourceAndValue({
-              newFormValidatorError,
-              isPreviousErrorFromFormValidator:
-              // These conditional checks are required, otherwise we get runtime errors.
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              currentErrorMapSource?.[errorMapKey] === "form",
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              previousErrorValue: currentErrorMap?.[errorMapKey]
-            });
-            if (newSource === "form") {
-              currentValidationErrorMap[field] = {
-                ...currentValidationErrorMap[field],
-                [errorMapKey]: newFormValidatorError
-              };
-            }
-            if (currentErrorMap?.[errorMapKey] !== newErrorValue) {
-              this.setFieldMeta(field, (prev = defaultFieldMeta) => ({
-                ...prev,
-                errorMap: {
-                  ...prev.errorMap,
-                  [errorMapKey]: newErrorValue
-                },
-                errorSourceMap: {
-                  ...prev.errorSourceMap,
-                  [errorMapKey]: newSource
-                }
-              }));
-            }
-          }
-          if (this.state.errorMap?.[errorMapKey] !== formError) {
-            this.baseStore.setState(prev => ({
-              ...prev,
-              errorMap: {
-                ...prev.errorMap,
-                [errorMapKey]: formError
-              }
-            }));
-          }
-          if (formError || fieldErrors) {
-            hasErrored = true;
-          }
-        }
-        const submitErrKey = getErrorMapKey$1("submit");
-        if (
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        this.state.errorMap?.[submitErrKey] && cause !== "submit" && !hasErrored) {
-          this.baseStore.setState(prev => ({
-            ...prev,
-            errorMap: {
-              ...prev.errorMap,
-              [submitErrKey]: void 0
-            }
-          }));
-        }
-        const serverErrKey = getErrorMapKey$1("server");
-        if (
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        this.state.errorMap?.[serverErrKey] && cause !== "server" && !hasErrored) {
-          this.baseStore.setState(prev => ({
-            ...prev,
-            errorMap: {
-              ...prev.errorMap,
-              [serverErrKey]: void 0
-            }
-          }));
-        }
-      });
-      return {
-        hasErrored,
-        fieldsErrorMap: currentValidationErrorMap
-      };
-    };
-    this.validateAsync = async cause => {
-      const validates = getAsyncValidatorArray(cause, {
-        ...this.options,
-        form: this,
-        validationLogic: this.options.validationLogic || defaultValidationLogic
-      });
-      if (!this.state.isFormValidating) {
-        this.baseStore.setState(prev => ({
-          ...prev,
-          isFormValidating: true
-        }));
-      }
-      const promises = [];
-      let fieldErrorsFromFormValidators;
-      for (const validateObj of validates) {
-        if (!validateObj.validate) continue;
-        const key = getErrorMapKey$1(validateObj.cause);
-        const fieldValidatorMeta = this.state.validationMetaMap[key];
-        fieldValidatorMeta?.lastAbortController.abort();
-        const controller = new AbortController();
-        this.state.validationMetaMap[key] = {
-          lastAbortController: controller
-        };
-        promises.push(new Promise(async resolve => {
-          let rawError;
-          try {
-            rawError = await new Promise((rawResolve, rawReject) => {
-              setTimeout(async () => {
-                if (controller.signal.aborted) return rawResolve(void 0);
-                try {
-                  rawResolve(await this.runValidator({
-                    validate: validateObj.validate,
-                    value: {
-                      value: this.state.values,
-                      formApi: this,
-                      validationSource: "form",
-                      signal: controller.signal
-                    },
-                    type: "validateAsync"
-                  }));
-                } catch (e) {
-                  rawReject(e);
-                }
-              }, validateObj.debounceMs);
-            });
-          } catch (e) {
-            rawError = e;
-          }
-          const {
-            formError,
-            fieldErrors: fieldErrorsFromNormalizeError
-          } = normalizeError$1(rawError);
-          if (fieldErrorsFromNormalizeError) {
-            fieldErrorsFromFormValidators = fieldErrorsFromFormValidators ? {
-              ...fieldErrorsFromFormValidators,
-              ...fieldErrorsFromNormalizeError
-            } : fieldErrorsFromNormalizeError;
-          }
-          const errorMapKey = getErrorMapKey$1(validateObj.cause);
-          for (const field of Object.keys(this.state.fieldMeta)) {
-            if (this.baseStore.state.fieldMetaBase[field] === void 0) {
-              continue;
-            }
-            const fieldMeta = this.getFieldMeta(field);
-            if (!fieldMeta) continue;
-            const {
-              errorMap: currentErrorMap,
-              errorSourceMap: currentErrorMapSource
-            } = fieldMeta;
-            const newFormValidatorError = fieldErrorsFromFormValidators?.[field];
-            const {
-              newErrorValue,
-              newSource
-            } = determineFormLevelErrorSourceAndValue({
-              newFormValidatorError,
-              isPreviousErrorFromFormValidator:
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              currentErrorMapSource?.[errorMapKey] === "form",
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              previousErrorValue: currentErrorMap?.[errorMapKey]
-            });
-            if (
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            currentErrorMap?.[errorMapKey] !== newErrorValue) {
-              this.setFieldMeta(field, prev => ({
-                ...prev,
-                errorMap: {
-                  ...prev.errorMap,
-                  [errorMapKey]: newErrorValue
-                },
-                errorSourceMap: {
-                  ...prev.errorSourceMap,
-                  [errorMapKey]: newSource
-                }
-              }));
-            }
-          }
-          this.baseStore.setState(prev => ({
-            ...prev,
-            errorMap: {
-              ...prev.errorMap,
-              [errorMapKey]: formError
-            }
-          }));
-          resolve(fieldErrorsFromFormValidators ? {
-            fieldErrors: fieldErrorsFromFormValidators,
-            errorMapKey
-          } : void 0);
-        }));
-      }
-      let results = [];
-      const fieldsErrorMap = {};
-      if (promises.length) {
-        results = await Promise.all(promises);
-        for (const fieldValidationResult of results) {
-          if (fieldValidationResult?.fieldErrors) {
-            const {
-              errorMapKey
-            } = fieldValidationResult;
-            for (const [field, fieldError] of Object.entries(fieldValidationResult.fieldErrors)) {
-              const oldErrorMap = fieldsErrorMap[field] || {};
-              const newErrorMap = {
-                ...oldErrorMap,
-                [errorMapKey]: fieldError
-              };
-              fieldsErrorMap[field] = newErrorMap;
-            }
-          }
-        }
-      }
-      this.baseStore.setState(prev => ({
-        ...prev,
-        isFormValidating: false
-      }));
-      return fieldsErrorMap;
-    };
-    this.validate = cause => {
-      const {
-        hasErrored,
-        fieldsErrorMap
-      } = this.validateSync(cause);
-      if (hasErrored && !this.options.asyncAlways) {
-        return fieldsErrorMap;
-      }
-      return this.validateAsync(cause);
-    };
-    this._handleSubmit = async submitMeta => {
-      this.baseStore.setState(old => ({
-        ...old,
-        // Submission attempts mark the form as not submitted
-        isSubmitted: false,
-        // Count submission attempts
-        submissionAttempts: old.submissionAttempts + 1,
-        isSubmitSuccessful: false
-        // Reset isSubmitSuccessful at the start of submission
-      }));
-      batch(() => {
-        void Object.values(this.fieldInfo).forEach(field => {
-          if (!field.instance) return;
-          if (!field.instance.state.meta.isTouched) {
-            field.instance.setMeta(prev => ({
-              ...prev,
-              isTouched: true
-            }));
-          }
-        });
-      });
-      const submitMetaArg = submitMeta ?? this.options.onSubmitMeta;
-      if (!this.state.canSubmit && !this._devtoolsSubmissionOverride) {
-        this.options.onSubmitInvalid?.({
-          value: this.state.values,
-          formApi: this,
-          meta: submitMetaArg
-        });
-        return;
-      }
-      this.baseStore.setState(d => ({
-        ...d,
-        isSubmitting: true
-      }));
-      const done = () => {
-        this.baseStore.setState(prev => ({
-          ...prev,
-          isSubmitting: false
-        }));
-      };
-      await this.validateAllFields("submit");
-      if (!this.state.isFieldsValid) {
-        done();
-        this.options.onSubmitInvalid?.({
-          value: this.state.values,
-          formApi: this,
-          meta: submitMetaArg
-        });
-        formEventClient.emit("form-submission", {
-          id: this._formId,
-          submissionAttempt: this.state.submissionAttempts,
-          successful: false,
-          stage: "validateAllFields",
-          errors: Object.values(this.state.fieldMeta).map(meta => meta.errors).flat()
-        });
-        return;
-      }
-      await this.validate("submit");
-      if (!this.state.isValid) {
-        done();
-        this.options.onSubmitInvalid?.({
-          value: this.state.values,
-          formApi: this,
-          meta: submitMetaArg
-        });
-        formEventClient.emit("form-submission", {
-          id: this._formId,
-          submissionAttempt: this.state.submissionAttempts,
-          successful: false,
-          stage: "validate",
-          errors: this.state.errors
-        });
-        return;
-      }
-      batch(() => {
-        void Object.values(this.fieldInfo).forEach(field => {
-          field.instance?.options.listeners?.onSubmit?.({
-            value: field.instance.state.value,
-            fieldApi: field.instance
-          });
-        });
-      });
-      this.options.listeners?.onSubmit?.({
-        formApi: this,
-        meta: submitMetaArg
-      });
-      try {
-        await this.options.onSubmit?.({
-          value: this.state.values,
-          formApi: this,
-          meta: submitMetaArg
-        });
-        batch(() => {
-          this.baseStore.setState(prev => ({
-            ...prev,
-            isSubmitted: true,
-            isSubmitSuccessful: true
-            // Set isSubmitSuccessful to true on successful submission
-          }));
-          formEventClient.emit("form-submission", {
-            id: this._formId,
-            submissionAttempt: this.state.submissionAttempts,
-            successful: true
-          });
-          done();
-        });
-      } catch (err) {
-        this.baseStore.setState(prev => ({
-          ...prev,
-          isSubmitSuccessful: false
-          // Ensure isSubmitSuccessful is false if an error occurs
-        }));
-        formEventClient.emit("form-submission", {
-          id: this._formId,
-          submissionAttempt: this.state.submissionAttempts,
-          successful: false,
-          stage: "inflight",
-          onError: err
-        });
-        done();
-        throw err;
-      }
-    };
-    this.getFieldValue = field => getBy(this.state.values, field);
-    this.getFieldMeta = field => {
-      return this.state.fieldMeta[field];
-    };
-    this.getFieldInfo = field => {
-      return this.fieldInfo[field] ||= {
-        instance: null,
-        validationMetaMap: {
-          onChange: void 0,
-          onBlur: void 0,
-          onSubmit: void 0,
-          onMount: void 0,
-          onServer: void 0,
-          onDynamic: void 0
-        }
-      };
-    };
-    this.setFieldMeta = (field, updater) => {
-      this.baseStore.setState(prev => {
-        return {
-          ...prev,
-          fieldMetaBase: {
-            ...prev.fieldMetaBase,
-            [field]: functionalUpdate(updater, prev.fieldMetaBase[field])
-          }
-        };
-      });
-    };
-    this.resetFieldMeta = fieldMeta => {
-      return Object.keys(fieldMeta).reduce((acc, key) => {
-        const fieldKey = key;
-        acc[fieldKey] = defaultFieldMeta;
-        return acc;
-      }, {});
-    };
-    this.setFieldValue = (field, updater, opts2) => {
-      const dontUpdateMeta = opts2?.dontUpdateMeta ?? false;
-      const dontRunListeners = opts2?.dontRunListeners ?? false;
-      const dontValidate = opts2?.dontValidate ?? false;
-      batch(() => {
-        if (!dontUpdateMeta) {
-          this.setFieldMeta(field, prev => ({
-            ...prev,
-            isTouched: true,
-            isDirty: true,
-            errorMap: {
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              ...prev?.errorMap,
-              onMount: void 0
-            }
-          }));
-        }
-        this.baseStore.setState(prev => {
-          return {
-            ...prev,
-            values: setBy(prev.values, field, updater)
-          };
-        });
-      });
-      if (!dontRunListeners) {
-        this.getFieldInfo(field).instance?.triggerOnChangeListener();
-      }
-      if (!dontValidate) {
-        this.validateField(field, "change");
-      }
-    };
-    this.deleteField = field => {
-      const subFieldsToDelete = Object.keys(this.fieldInfo).filter(f => {
-        const fieldStr = field.toString();
-        return f !== fieldStr && f.startsWith(fieldStr);
-      });
-      const fieldsToDelete = [...subFieldsToDelete, field];
-      this.baseStore.setState(prev => {
-        const newState = {
-          ...prev
-        };
-        fieldsToDelete.forEach(f => {
-          newState.values = deleteBy(newState.values, f);
-          delete this.fieldInfo[f];
-          delete newState.fieldMetaBase[f];
-        });
-        return newState;
-      });
-    };
-    this.pushFieldValue = (field, value, options) => {
-      this.setFieldValue(field, prev => [...(Array.isArray(prev) ? prev : []), value], options);
-    };
-    this.insertFieldValue = async (field, index, value, options) => {
-      this.setFieldValue(field, prev => {
-        return [...prev.slice(0, index), value, ...prev.slice(index)];
-      }, mergeOpts(options, {
-        dontValidate: true
-      }));
-      const dontValidate = options?.dontValidate ?? false;
-      if (!dontValidate) {
-        await this.validateField(field, "change");
-      }
-      metaHelper(this).handleArrayInsert(field, index);
-      if (!dontValidate) {
-        await this.validateArrayFieldsStartingFrom(field, index, "change");
-      }
-    };
-    this.replaceFieldValue = async (field, index, value, options) => {
-      this.setFieldValue(field, prev => {
-        return prev.map((d, i) => i === index ? value : d);
-      }, mergeOpts(options, {
-        dontValidate: true
-      }));
-      const dontValidate = options?.dontValidate ?? false;
-      if (!dontValidate) {
-        await this.validateField(field, "change");
-        await this.validateArrayFieldsStartingFrom(field, index, "change");
-      }
-    };
-    this.removeFieldValue = async (field, index, options) => {
-      const fieldValue = this.getFieldValue(field);
-      const lastIndex = Array.isArray(fieldValue) ? Math.max(fieldValue.length - 1, 0) : null;
-      this.setFieldValue(field, prev => {
-        return prev.filter((_d, i) => i !== index);
-      }, mergeOpts(options, {
-        dontValidate: true
-      }));
-      metaHelper(this).handleArrayRemove(field, index);
-      if (lastIndex !== null) {
-        const start = `${field}[${lastIndex}]`;
-        this.deleteField(start);
-      }
-      const dontValidate = options?.dontValidate ?? false;
-      if (!dontValidate) {
-        await this.validateField(field, "change");
-        await this.validateArrayFieldsStartingFrom(field, index, "change");
-      }
-    };
-    this.swapFieldValues = (field, index1, index2, options) => {
-      this.setFieldValue(field, prev => {
-        const prev1 = prev[index1];
-        const prev2 = prev[index2];
-        return setBy(setBy(prev, `${index1}`, prev2), `${index2}`, prev1);
-      }, mergeOpts(options, {
-        dontValidate: true
-      }));
-      metaHelper(this).handleArraySwap(field, index1, index2);
-      const dontValidate = options?.dontValidate ?? false;
-      if (!dontValidate) {
-        this.validateField(field, "change");
-        this.validateField(`${field}[${index1}]`, "change");
-        this.validateField(`${field}[${index2}]`, "change");
-      }
-    };
-    this.moveFieldValues = (field, index1, index2, options) => {
-      this.setFieldValue(field, prev => {
-        const next = [...prev];
-        next.splice(index2, 0, next.splice(index1, 1)[0]);
-        return next;
-      }, mergeOpts(options, {
-        dontValidate: true
-      }));
-      metaHelper(this).handleArrayMove(field, index1, index2);
-      const dontValidate = options?.dontValidate ?? false;
-      if (!dontValidate) {
-        this.validateField(field, "change");
-        this.validateField(`${field}[${index1}]`, "change");
-        this.validateField(`${field}[${index2}]`, "change");
-      }
-    };
-    this.clearFieldValues = (field, options) => {
-      const fieldValue = this.getFieldValue(field);
-      const lastIndex = Array.isArray(fieldValue) ? Math.max(fieldValue.length - 1, 0) : null;
-      this.setFieldValue(field, [], mergeOpts(options, {
-        dontValidate: true
-      }));
-      if (lastIndex !== null) {
-        for (let i = 0; i <= lastIndex; i++) {
-          const fieldKey = `${field}[${i}]`;
-          this.deleteField(fieldKey);
-        }
-      }
-      const dontValidate = options?.dontValidate ?? false;
-      if (!dontValidate) {
-        this.validateField(field, "change");
-      }
-    };
-    this.resetField = field => {
-      this.baseStore.setState(prev => {
-        return {
-          ...prev,
-          fieldMetaBase: {
-            ...prev.fieldMetaBase,
-            [field]: defaultFieldMeta
-          },
-          values: this.options.defaultValues ? setBy(prev.values, field, getBy(this.options.defaultValues, field)) : prev.values
-        };
-      });
-    };
-    this.setErrorMap = errorMap => {
-      batch(() => {
-        Object.entries(errorMap).forEach(([key, value]) => {
-          const errorMapKey = key;
-          if (isGlobalFormValidationError(value)) {
-            const {
-              formError,
-              fieldErrors
-            } = normalizeError$1(value);
-            for (const fieldName of Object.keys(this.fieldInfo)) {
-              const fieldMeta = this.getFieldMeta(fieldName);
-              if (!fieldMeta) continue;
-              this.setFieldMeta(fieldName, prev => ({
-                ...prev,
-                errorMap: {
-                  ...prev.errorMap,
-                  [errorMapKey]: fieldErrors?.[fieldName]
-                },
-                errorSourceMap: {
-                  ...prev.errorSourceMap,
-                  [errorMapKey]: "form"
-                }
-              }));
-            }
-            this.baseStore.setState(prev => ({
-              ...prev,
-              errorMap: {
-                ...prev.errorMap,
-                [errorMapKey]: formError
-              }
-            }));
-          } else {
-            this.baseStore.setState(prev => ({
-              ...prev,
-              errorMap: {
-                ...prev.errorMap,
-                [errorMapKey]: value
-              }
-            }));
-          }
-        });
-      });
-    };
-    this.getAllErrors = () => {
-      return {
-        form: {
-          errors: this.state.errors,
-          errorMap: this.state.errorMap
-        },
-        fields: Object.entries(this.state.fieldMeta).reduce((acc, [fieldName, fieldMeta]) => {
-          if (Object.keys(fieldMeta).length && fieldMeta.errors.length) {
-            acc[fieldName] = {
-              errors: fieldMeta.errors,
-              errorMap: fieldMeta.errorMap
-            };
-          }
-          return acc;
-        }, {})
-      };
-    };
-    this.parseValuesWithSchema = schema => {
-      return standardSchemaValidators.validate({
-        value: this.state.values,
-        validationSource: "form"
-      }, schema);
-    };
-    this.parseValuesWithSchemaAsync = schema => {
-      return standardSchemaValidators.validateAsync({
-        value: this.state.values,
-        validationSource: "form"
-      }, schema);
-    };
-    this.timeoutIds = {
-      validations: {},
-      listeners: {},
-      formListeners: {}
-    };
-    this._formId = opts?.formId ?? uuid();
-    this._devtoolsSubmissionOverride = false;
-    this.baseStore = new Store(getDefaultFormState({
-      ...opts?.defaultState,
-      values: opts?.defaultValues ?? opts?.defaultState?.values
-    }));
-    this.fieldMetaDerived = new Derived({
-      deps: [this.baseStore],
-      fn: ({
-        prevDepVals,
-        currDepVals,
-        prevVal: _prevVal
-      }) => {
-        const prevVal = _prevVal;
-        const prevBaseStore = prevDepVals?.[0];
-        const currBaseStore = currDepVals[0];
-        let originalMetaCount = 0;
-        const fieldMeta = {};
-        for (const fieldName of Object.keys(currBaseStore.fieldMetaBase)) {
-          const currBaseMeta = currBaseStore.fieldMetaBase[fieldName];
-          const prevBaseMeta = prevBaseStore?.fieldMetaBase[fieldName];
-          const prevFieldInfo = prevVal?.[fieldName];
-          const curFieldVal = getBy(currBaseStore.values, fieldName);
-          let fieldErrors = prevFieldInfo?.errors;
-          if (!prevBaseMeta || currBaseMeta.errorMap !== prevBaseMeta.errorMap) {
-            fieldErrors = Object.values(currBaseMeta.errorMap ?? {}).filter(val => val !== void 0);
-            const fieldInstance = this.getFieldInfo(fieldName)?.instance;
-            if (!fieldInstance || !fieldInstance.options.disableErrorFlat) {
-              fieldErrors = fieldErrors.flat(1);
-            }
-          }
-          const isFieldValid = !isNonEmptyArray(fieldErrors);
-          const isFieldPristine = !currBaseMeta.isDirty;
-          const isDefaultValue = evaluate(curFieldVal, getBy(this.options.defaultValues, fieldName)) || evaluate(curFieldVal,
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-          this.getFieldInfo(fieldName)?.instance?.options.defaultValue);
-          if (prevFieldInfo && prevFieldInfo.isPristine === isFieldPristine && prevFieldInfo.isValid === isFieldValid && prevFieldInfo.isDefaultValue === isDefaultValue && prevFieldInfo.errors === fieldErrors && currBaseMeta === prevBaseMeta) {
-            fieldMeta[fieldName] = prevFieldInfo;
-            originalMetaCount++;
-            continue;
-          }
-          fieldMeta[fieldName] = {
-            ...currBaseMeta,
-            errors: fieldErrors ?? [],
-            isPristine: isFieldPristine,
-            isValid: isFieldValid,
-            isDefaultValue
-          };
-        }
-        if (!Object.keys(currBaseStore.fieldMetaBase).length) return fieldMeta;
-        if (prevVal && originalMetaCount === Object.keys(currBaseStore.fieldMetaBase).length) {
-          return prevVal;
-        }
-        return fieldMeta;
-      }
-    });
-    this.store = new Derived({
-      deps: [this.baseStore, this.fieldMetaDerived],
-      fn: ({
-        prevDepVals,
-        currDepVals,
-        prevVal: _prevVal
-      }) => {
-        const prevVal = _prevVal;
-        const prevBaseStore = prevDepVals?.[0];
-        const currBaseStore = currDepVals[0];
-        const currFieldMeta = currDepVals[1];
-        const fieldMetaValues = Object.values(currFieldMeta).filter(Boolean);
-        const isFieldsValidating = fieldMetaValues.some(field => field.isValidating);
-        const isFieldsValid = fieldMetaValues.every(field => field.isValid);
-        const isTouched = fieldMetaValues.some(field => field.isTouched);
-        const isBlurred = fieldMetaValues.some(field => field.isBlurred);
-        const isDefaultValue = fieldMetaValues.every(field => field.isDefaultValue);
-        const shouldInvalidateOnMount =
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        isTouched && currBaseStore.errorMap?.onMount;
-        const isDirty = fieldMetaValues.some(field => field.isDirty);
-        const isPristine = !isDirty;
-        const hasOnMountError = Boolean(
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        currBaseStore.errorMap?.onMount ||
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        fieldMetaValues.some(f => f?.errorMap?.onMount));
-        const isValidating = !!isFieldsValidating;
-        let errors = prevVal?.errors ?? [];
-        if (!prevBaseStore || currBaseStore.errorMap !== prevBaseStore.errorMap) {
-          errors = Object.values(currBaseStore.errorMap).reduce((prev, curr) => {
-            if (curr === void 0) return prev;
-            if (curr && isGlobalFormValidationError(curr)) {
-              prev.push(curr.form);
-              return prev;
-            }
-            prev.push(curr);
-            return prev;
-          }, []);
-        }
-        const isFormValid = errors.length === 0;
-        const isValid = isFieldsValid && isFormValid;
-        const submitInvalid = this.options.canSubmitWhenInvalid ?? false;
-        const canSubmit = currBaseStore.submissionAttempts === 0 && !isTouched && !hasOnMountError || !isValidating && !currBaseStore.isSubmitting && isValid || submitInvalid;
-        let errorMap = currBaseStore.errorMap;
-        if (shouldInvalidateOnMount) {
-          errors = errors.filter(err => err !== currBaseStore.errorMap.onMount);
-          errorMap = Object.assign(errorMap, {
-            onMount: void 0
-          });
-        }
-        if (prevVal && prevBaseStore && prevVal.errorMap === errorMap && prevVal.fieldMeta === this.fieldMetaDerived.state && prevVal.errors === errors && prevVal.isFieldsValidating === isFieldsValidating && prevVal.isFieldsValid === isFieldsValid && prevVal.isFormValid === isFormValid && prevVal.isValid === isValid && prevVal.canSubmit === canSubmit && prevVal.isTouched === isTouched && prevVal.isBlurred === isBlurred && prevVal.isPristine === isPristine && prevVal.isDefaultValue === isDefaultValue && prevVal.isDirty === isDirty && evaluate(prevBaseStore, currBaseStore)) {
-          return prevVal;
-        }
-        let state = {
-          ...currBaseStore,
-          errorMap,
-          fieldMeta: this.fieldMetaDerived.state,
-          errors,
-          isFieldsValidating,
-          isFieldsValid,
-          isFormValid,
-          isValid,
-          canSubmit,
-          isTouched,
-          isBlurred,
-          isPristine,
-          isDefaultValue,
-          isDirty
-        };
-        const transformArray = this.options.transform?.deps ?? [];
-        const shouldTransform = transformArray.length !== this.prevTransformArray.length || transformArray.some((val, i) => val !== this.prevTransformArray[i]);
-        if (shouldTransform) {
-          const newObj = Object.assign({}, this, {
-            state
-          });
-          this.options.transform?.fn(newObj);
-          state = newObj.state;
-          this.prevTransformArray = transformArray;
-        }
-        return state;
-      }
-    });
-    this.handleSubmit = this.handleSubmit.bind(this);
-    this.update(opts || {});
-  }
-  get state() {
-    return this.store.state;
-  }
-  get formId() {
-    return this._formId;
-  }
-  /**
-   * @private
-   */
-  runValidator(props) {
-    if (isStandardSchemaValidator(props.validate)) {
-      return standardSchemaValidators[props.type](props.value, props.validate);
-    }
-    return props.validate(props.value);
-  }
-  handleSubmit(submitMeta) {
-    return this._handleSubmit(submitMeta);
-  }
-}
-function normalizeError$1(rawError) {
-  if (rawError) {
-    if (isGlobalFormValidationError(rawError)) {
-      const formError = normalizeError$1(rawError.form).formError;
-      const fieldErrors = rawError.fields;
-      return {
-        formError,
-        fieldErrors
-      };
-    }
-    return {
-      formError: rawError
-    };
-  }
-  return {
-    formError: void 0
-  };
-}
-function getErrorMapKey$1(cause) {
-  switch (cause) {
-    case "submit":
-      return "onSubmit";
-    case "blur":
-      return "onBlur";
-    case "mount":
-      return "onMount";
-    case "server":
-      return "onServer";
-    case "dynamic":
-      return "onDynamic";
-    case "change":
-    default:
-      return "onChange";
-  }
-}class FieldApi {
-  /**
-   * Initializes a new `FieldApi` instance.
-   */
-  constructor(opts) {
-    this.options = {};
-    this.mount = () => {
-      const cleanup = this.store.mount();
-      if (this.options.defaultValue !== void 0 && !this.getMeta().isTouched) {
-        this.form.setFieldValue(this.name, this.options.defaultValue, {
-          dontUpdateMeta: true
-        });
-      }
-      const info = this.getInfo();
-      info.instance = this;
-      this.update(this.options);
-      const {
-        onMount
-      } = this.options.validators || {};
-      if (onMount) {
-        const error = this.runValidator({
-          validate: onMount,
-          value: {
-            value: this.state.value,
-            fieldApi: this,
-            validationSource: "field"
-          },
-          type: "validate"
-        });
-        if (error) {
-          this.setMeta(prev => ({
-            ...prev,
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            errorMap: {
-              ...prev?.errorMap,
-              onMount: error
-            },
-            errorSourceMap: {
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              ...prev?.errorSourceMap,
-              onMount: "field"
-            }
-          }));
-        }
-      }
-      this.options.listeners?.onMount?.({
-        value: this.state.value,
-        fieldApi: this
-      });
-      return cleanup;
-    };
-    this.update = opts2 => {
-      this.options = opts2;
-      this.name = opts2.name;
-      if (!this.state.meta.isTouched && this.options.defaultValue !== void 0) {
-        const formField = this.form.getFieldValue(this.name);
-        if (!evaluate(formField, opts2.defaultValue)) {
-          this.form.setFieldValue(this.name, opts2.defaultValue, {
-            dontUpdateMeta: true,
-            dontValidate: true,
-            dontRunListeners: true
-          });
-        }
-      }
-      if (!this.form.getFieldMeta(this.name)) {
-        this.form.setFieldMeta(this.name, this.state.meta);
-      }
-    };
-    this.getValue = () => {
-      return this.form.getFieldValue(this.name);
-    };
-    this.setValue = (updater, options) => {
-      this.form.setFieldValue(this.name, updater, mergeOpts(options, {
-        dontRunListeners: true,
-        dontValidate: true
-      }));
-      if (!options?.dontRunListeners) {
-        this.triggerOnChangeListener();
-      }
-      if (!options?.dontValidate) {
-        this.validate("change");
-      }
-    };
-    this.getMeta = () => this.store.state.meta;
-    this.setMeta = updater => this.form.setFieldMeta(this.name, updater);
-    this.getInfo = () => this.form.getFieldInfo(this.name);
-    this.pushValue = (value, options) => {
-      this.form.pushFieldValue(this.name, value, mergeOpts(options, {
-        dontRunListeners: true
-      }));
-      if (!options?.dontRunListeners) {
-        this.triggerOnChangeListener();
-      }
-    };
-    this.insertValue = (index, value, options) => {
-      this.form.insertFieldValue(this.name, index, value, mergeOpts(options, {
-        dontRunListeners: true
-      }));
-      if (!options?.dontRunListeners) {
-        this.triggerOnChangeListener();
-      }
-    };
-    this.replaceValue = (index, value, options) => {
-      this.form.replaceFieldValue(this.name, index, value, mergeOpts(options, {
-        dontRunListeners: true
-      }));
-      if (!options?.dontRunListeners) {
-        this.triggerOnChangeListener();
-      }
-    };
-    this.removeValue = (index, options) => {
-      this.form.removeFieldValue(this.name, index, mergeOpts(options, {
-        dontRunListeners: true
-      }));
-      if (!options?.dontRunListeners) {
-        this.triggerOnChangeListener();
-      }
-    };
-    this.swapValues = (aIndex, bIndex, options) => {
-      this.form.swapFieldValues(this.name, aIndex, bIndex, mergeOpts(options, {
-        dontRunListeners: true
-      }));
-      if (!options?.dontRunListeners) {
-        this.triggerOnChangeListener();
-      }
-    };
-    this.moveValue = (aIndex, bIndex, options) => {
-      this.form.moveFieldValues(this.name, aIndex, bIndex, mergeOpts(options, {
-        dontRunListeners: true
-      }));
-      if (!options?.dontRunListeners) {
-        this.triggerOnChangeListener();
-      }
-    };
-    this.clearValues = options => {
-      this.form.clearFieldValues(this.name, mergeOpts(options, {
-        dontRunListeners: true
-      }));
-      if (!options?.dontRunListeners) {
-        this.triggerOnChangeListener();
-      }
-    };
-    this.getLinkedFields = cause => {
-      const fields = Object.values(this.form.fieldInfo);
-      const linkedFields = [];
-      for (const field of fields) {
-        if (!field.instance) continue;
-        const {
-          onChangeListenTo,
-          onBlurListenTo
-        } = field.instance.options.validators || {};
-        if (cause === "change" && onChangeListenTo?.includes(this.name)) {
-          linkedFields.push(field.instance);
-        }
-        if (cause === "blur" && onBlurListenTo?.includes(this.name)) {
-          linkedFields.push(field.instance);
-        }
-      }
-      return linkedFields;
-    };
-    this.validateSync = (cause, errorFromForm) => {
-      const validates = getSyncValidatorArray(cause, {
-        ...this.options,
-        form: this.form,
-        validationLogic: this.form.options.validationLogic || defaultValidationLogic
-      });
-      const linkedFields = this.getLinkedFields(cause);
-      const linkedFieldValidates = linkedFields.reduce((acc, field) => {
-        const fieldValidates = getSyncValidatorArray(cause, {
-          ...field.options,
-          form: field.form,
-          validationLogic: field.form.options.validationLogic || defaultValidationLogic
-        });
-        fieldValidates.forEach(validate => {
-          validate.field = field;
-        });
-        return acc.concat(fieldValidates);
-      }, []);
-      let hasErrored = false;
-      batch(() => {
-        const validateFieldFn = (field, validateObj) => {
-          const errorMapKey = getErrorMapKey(validateObj.cause);
-          const fieldLevelError = validateObj.validate ? normalizeError(field.runValidator({
-            validate: validateObj.validate,
-            value: {
-              value: field.store.state.value,
-              validationSource: "field",
-              fieldApi: field
-            },
-            type: "validate"
-          })) : void 0;
-          const formLevelError = errorFromForm[errorMapKey];
-          const {
-            newErrorValue,
-            newSource
-          } = determineFieldLevelErrorSourceAndValue({
-            formLevelError,
-            fieldLevelError
-          });
-          if (field.state.meta.errorMap?.[errorMapKey] !== newErrorValue) {
-            field.setMeta(prev => ({
-              ...prev,
-              errorMap: {
-                ...prev.errorMap,
-                [errorMapKey]: newErrorValue
-              },
-              errorSourceMap: {
-                ...prev.errorSourceMap,
-                [errorMapKey]: newSource
-              }
-            }));
-          }
-          if (newErrorValue) {
-            hasErrored = true;
-          }
-        };
-        for (const validateObj of validates) {
-          validateFieldFn(this, validateObj);
-        }
-        for (const fieldValitateObj of linkedFieldValidates) {
-          if (!fieldValitateObj.validate) continue;
-          validateFieldFn(fieldValitateObj.field, fieldValitateObj);
-        }
-      });
-      const submitErrKey = getErrorMapKey("submit");
-      if (
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      this.state.meta.errorMap?.[submitErrKey] && cause !== "submit" && !hasErrored) {
-        this.setMeta(prev => ({
-          ...prev,
-          errorMap: {
-            ...prev.errorMap,
-            [submitErrKey]: void 0
-          },
-          errorSourceMap: {
-            ...prev.errorSourceMap,
-            [submitErrKey]: void 0
-          }
-        }));
-      }
-      return {
-        hasErrored
-      };
-    };
-    this.validateAsync = async (cause, formValidationResultPromise) => {
-      const validates = getAsyncValidatorArray(cause, {
-        ...this.options,
-        form: this.form,
-        validationLogic: this.form.options.validationLogic || defaultValidationLogic
-      });
-      const asyncFormValidationResults = await formValidationResultPromise;
-      const linkedFields = this.getLinkedFields(cause);
-      const linkedFieldValidates = linkedFields.reduce((acc, field) => {
-        const fieldValidates = getAsyncValidatorArray(cause, {
-          ...field.options,
-          form: field.form,
-          validationLogic: field.form.options.validationLogic || defaultValidationLogic
-        });
-        fieldValidates.forEach(validate => {
-          validate.field = field;
-        });
-        return acc.concat(fieldValidates);
-      }, []);
-      const validatesPromises = [];
-      const linkedPromises = [];
-      const hasAsyncValidators = validates.some(v => v.validate) || linkedFieldValidates.some(v => v.validate);
-      if (hasAsyncValidators) {
-        if (!this.state.meta.isValidating) {
-          this.setMeta(prev => ({
-            ...prev,
-            isValidating: true
-          }));
-        }
-        for (const linkedField of linkedFields) {
-          linkedField.setMeta(prev => ({
-            ...prev,
-            isValidating: true
-          }));
-        }
-      }
-      const validateFieldAsyncFn = (field, validateObj, promises) => {
-        const errorMapKey = getErrorMapKey(validateObj.cause);
-        const fieldValidatorMeta = field.getInfo().validationMetaMap[errorMapKey];
-        fieldValidatorMeta?.lastAbortController.abort();
-        const controller = new AbortController();
-        this.getInfo().validationMetaMap[errorMapKey] = {
-          lastAbortController: controller
-        };
-        promises.push(new Promise(async resolve => {
-          let rawError;
-          try {
-            rawError = await new Promise((rawResolve, rawReject) => {
-              if (this.timeoutIds.validations[validateObj.cause]) {
-                clearTimeout(this.timeoutIds.validations[validateObj.cause]);
-              }
-              this.timeoutIds.validations[validateObj.cause] = setTimeout(async () => {
-                if (controller.signal.aborted) return rawResolve(void 0);
-                try {
-                  rawResolve(await this.runValidator({
-                    validate: validateObj.validate,
-                    value: {
-                      value: field.store.state.value,
-                      fieldApi: field,
-                      signal: controller.signal,
-                      validationSource: "field"
-                    },
-                    type: "validateAsync"
-                  }));
-                } catch (e) {
-                  rawReject(e);
-                }
-              }, validateObj.debounceMs);
-            });
-          } catch (e) {
-            rawError = e;
-          }
-          if (controller.signal.aborted) return resolve(void 0);
-          const fieldLevelError = normalizeError(rawError);
-          const formLevelError = asyncFormValidationResults[this.name]?.[errorMapKey];
-          const {
-            newErrorValue,
-            newSource
-          } = determineFieldLevelErrorSourceAndValue({
-            formLevelError,
-            fieldLevelError
-          });
-          field.setMeta(prev => {
-            return {
-              ...prev,
-              errorMap: {
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                ...prev?.errorMap,
-                [errorMapKey]: newErrorValue
-              },
-              errorSourceMap: {
-                ...prev.errorSourceMap,
-                [errorMapKey]: newSource
-              }
-            };
-          });
-          resolve(newErrorValue);
-        }));
-      };
-      for (const validateObj of validates) {
-        if (!validateObj.validate) continue;
-        validateFieldAsyncFn(this, validateObj, validatesPromises);
-      }
-      for (const fieldValitateObj of linkedFieldValidates) {
-        if (!fieldValitateObj.validate) continue;
-        validateFieldAsyncFn(fieldValitateObj.field, fieldValitateObj, linkedPromises);
-      }
-      let results = [];
-      if (validatesPromises.length || linkedPromises.length) {
-        results = await Promise.all(validatesPromises);
-        await Promise.all(linkedPromises);
-      }
-      if (hasAsyncValidators) {
-        this.setMeta(prev => ({
-          ...prev,
-          isValidating: false
-        }));
-        for (const linkedField of linkedFields) {
-          linkedField.setMeta(prev => ({
-            ...prev,
-            isValidating: false
-          }));
-        }
-      }
-      return results.filter(Boolean);
-    };
-    this.validate = (cause, opts2) => {
-      if (!this.state.meta.isTouched) return [];
-      const {
-        fieldsErrorMap
-      } = opts2?.skipFormValidation ? {
-        fieldsErrorMap: {}
-      } : this.form.validateSync(cause);
-      const {
-        hasErrored
-      } = this.validateSync(cause, fieldsErrorMap[this.name] ?? {});
-      if (hasErrored && !this.options.asyncAlways) {
-        this.getInfo().validationMetaMap[getErrorMapKey(cause)]?.lastAbortController.abort();
-        return this.state.meta.errors;
-      }
-      const formValidationResultPromise = opts2?.skipFormValidation ? Promise.resolve({}) : this.form.validateAsync(cause);
-      return this.validateAsync(cause, formValidationResultPromise);
-    };
-    this.handleChange = updater => {
-      this.setValue(updater);
-    };
-    this.handleBlur = () => {
-      const prevTouched = this.state.meta.isTouched;
-      if (!prevTouched) {
-        this.setMeta(prev => ({
-          ...prev,
-          isTouched: true
-        }));
-      }
-      if (!this.state.meta.isBlurred) {
-        this.setMeta(prev => ({
-          ...prev,
-          isBlurred: true
-        }));
-      }
-      this.validate("blur");
-      this.triggerOnBlurListener();
-    };
-    this.setErrorMap = errorMap => {
-      this.setMeta(prev => ({
-        ...prev,
-        errorMap: {
-          ...prev.errorMap,
-          ...errorMap
-        }
-      }));
-    };
-    this.parseValueWithSchema = schema => {
-      return standardSchemaValidators.validate({
-        value: this.state.value,
-        validationSource: "field"
-      }, schema);
-    };
-    this.parseValueWithSchemaAsync = schema => {
-      return standardSchemaValidators.validateAsync({
-        value: this.state.value,
-        validationSource: "field"
-      }, schema);
-    };
-    this.triggerOnChangeListener = () => {
-      const formDebounceMs = this.form.options.listeners?.onChangeDebounceMs;
-      if (formDebounceMs && formDebounceMs > 0) {
-        if (this.timeoutIds.formListeners.change) {
-          clearTimeout(this.timeoutIds.formListeners.change);
-        }
-        this.timeoutIds.formListeners.change = setTimeout(() => {
-          this.form.options.listeners?.onChange?.({
-            formApi: this.form,
-            fieldApi: this
-          });
-        }, formDebounceMs);
-      } else {
-        this.form.options.listeners?.onChange?.({
-          formApi: this.form,
-          fieldApi: this
-        });
-      }
-      const fieldDebounceMs = this.options.listeners?.onChangeDebounceMs;
-      if (fieldDebounceMs && fieldDebounceMs > 0) {
-        if (this.timeoutIds.listeners.change) {
-          clearTimeout(this.timeoutIds.listeners.change);
-        }
-        this.timeoutIds.listeners.change = setTimeout(() => {
-          this.options.listeners?.onChange?.({
-            value: this.state.value,
-            fieldApi: this
-          });
-        }, fieldDebounceMs);
-      } else {
-        this.options.listeners?.onChange?.({
-          value: this.state.value,
-          fieldApi: this
-        });
-      }
-    };
-    this.form = opts.form;
-    this.name = opts.name;
-    this.options = opts;
-    this.timeoutIds = {
-      validations: {},
-      listeners: {},
-      formListeners: {}
-    };
-    this.store = new Derived({
-      deps: [this.form.store],
-      fn: ({
-        prevVal: _prevVal
-      }) => {
-        const prevVal = _prevVal;
-        const meta = this.form.getFieldMeta(this.name) ?? {
-          ...defaultFieldMeta,
-          ...opts.defaultMeta
-        };
-        let value = this.form.getFieldValue(this.name);
-        if (!meta.isTouched && value === void 0 && this.options.defaultValue !== void 0 && !evaluate(value, this.options.defaultValue)) {
-          value = this.options.defaultValue;
-        }
-        if (prevVal && prevVal.value === value && prevVal.meta === meta) {
-          return prevVal;
-        }
-        return {
-          value,
-          meta
-        };
-      }
-    });
-  }
-  /**
-   * The current field state.
-   */
-  get state() {
-    return this.store.state;
-  }
-  /**
-   * @private
-   */
-  runValidator(props) {
-    if (isStandardSchemaValidator(props.validate)) {
-      return standardSchemaValidators[props.type](props.value, props.validate);
-    }
-    return props.validate(props.value);
-  }
-  triggerOnBlurListener() {
-    const formDebounceMs = this.form.options.listeners?.onBlurDebounceMs;
-    if (formDebounceMs && formDebounceMs > 0) {
-      if (this.timeoutIds.formListeners.blur) {
-        clearTimeout(this.timeoutIds.formListeners.blur);
-      }
-      this.timeoutIds.formListeners.blur = setTimeout(() => {
-        this.form.options.listeners?.onBlur?.({
-          formApi: this.form,
-          fieldApi: this
-        });
-      }, formDebounceMs);
-    } else {
-      this.form.options.listeners?.onBlur?.({
-        formApi: this.form,
-        fieldApi: this
-      });
-    }
-    const fieldDebounceMs = this.options.listeners?.onBlurDebounceMs;
-    if (fieldDebounceMs && fieldDebounceMs > 0) {
-      if (this.timeoutIds.listeners.blur) {
-        clearTimeout(this.timeoutIds.listeners.blur);
-      }
-      this.timeoutIds.listeners.blur = setTimeout(() => {
-        this.options.listeners?.onBlur?.({
-          value: this.state.value,
-          fieldApi: this
-        });
-      }, fieldDebounceMs);
-    } else {
-      this.options.listeners?.onBlur?.({
-        value: this.state.value,
-        fieldApi: this
-      });
-    }
-  }
-}
-function normalizeError(rawError) {
-  if (rawError) {
-    return rawError;
-  }
-  return void 0;
-}
-function getErrorMapKey(cause) {
-  switch (cause) {
-    case "submit":
-      return "onSubmit";
-    case "blur":
-      return "onBlur";
-    case "mount":
-      return "onMount";
-    case "server":
-      return "onServer";
-    case "dynamic":
-      return "onDynamic";
-    case "change":
-    default:
-      return "onChange";
-  }
-}function useStore$1(store, selector = (d) => d, options = {}) {
-  const equal = options.equal ?? shallow;
-  const slice = useSyncExternalStoreWithSelector(
-    store.subscribe,
-    () => store.state,
-    () => store.state,
-    selector,
-    equal
-  );
-  return slice;
-}
-function shallow(objA, objB) {
-  if (Object.is(objA, objB)) {
-    return true;
-  }
-  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
-    return false;
-  }
-  if (objA instanceof Map && objB instanceof Map) {
-    if (objA.size !== objB.size) return false;
-    for (const [k, v] of objA) {
-      if (!objB.has(k) || !Object.is(v, objB.get(k))) return false;
-    }
-    return true;
-  }
-  if (objA instanceof Set && objB instanceof Set) {
-    if (objA.size !== objB.size) return false;
-    for (const v of objA) {
-      if (!objB.has(v)) return false;
-    }
-    return true;
-  }
-  if (objA instanceof Date && objB instanceof Date) {
-    if (objA.getTime() !== objB.getTime()) return false;
-    return true;
-  }
-  const keysA = getOwnKeys(objA);
-  if (keysA.length !== getOwnKeys(objB).length) {
-    return false;
-  }
-  for (let i = 0; i < keysA.length; i++) {
-    if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) {
-      return false;
-    }
-  }
-  return true;
-}
-function getOwnKeys(obj) {
-  return Object.keys(obj).concat(
-    Object.getOwnPropertySymbols(obj)
-  );
-}const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;function useField(opts) {
-  const [prevOptions, setPrevOptions] = useState(() => ({
-    form: opts.form,
-    name: opts.name
-  }));
-  const [fieldApi, setFieldApi] = useState(() => {
-    return new FieldApi({
-      ...opts
+const {
+  atom: formConfigAtom,
+  useValue: useFormConfigValue,
+  useState: useFormConfigState,
+  useReset: useFormConfigReset
+} = atomStateGenerator({
+  key: 'formConfig',
+  defaultValue: _formConfig,
+  persist: false
+});const createDefaultContainer = () => {
+  return ({
+    children
+  }) => {
+    return children;
+  };
+};
+let DefaultContainer = createDefaultContainer();
+const setDefaultFormContainer = val => {
+  DefaultContainer = val;
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const DefaultFormContainer = t0 => {
+  const $ = c(2);
+  const {
+    children
+  } = t0;
+  const handleSubmit = _temp$1;
+  let t1;
+  if ($[0] !== children) {
+    t1 = jsx("form", {
+      onSubmit: handleSubmit,
+      className: "gap-3 flex flex-col",
+      children
     });
-  });
-  if (prevOptions.form !== opts.form || prevOptions.name !== opts.name) {
-    setFieldApi(
-      new FieldApi({
-        ...opts
-      })
-    );
-    setPrevOptions({ form: opts.form, name: opts.name });
-  }
-  const reactiveStateValue = useStore$1(
-    fieldApi.store,
-    opts.mode === "array" ? (state) => Object.keys(state.value ?? []).length : (state) => state.value
-  );
-  const reactiveMetaIsTouched = useStore$1(
-    fieldApi.store,
-    (state) => state.meta.isTouched
-  );
-  const reactiveMetaIsBlurred = useStore$1(
-    fieldApi.store,
-    (state) => state.meta.isBlurred
-  );
-  const reactiveMetaIsDirty = useStore$1(
-    fieldApi.store,
-    (state) => state.meta.isDirty
-  );
-  const reactiveMetaErrorMap = useStore$1(
-    fieldApi.store,
-    (state) => state.meta.errorMap
-  );
-  const reactiveMetaErrorSourceMap = useStore$1(
-    fieldApi.store,
-    (state) => state.meta.errorSourceMap
-  );
-  const reactiveMetaIsValidating = useStore$1(
-    fieldApi.store,
-    (state) => state.meta.isValidating
-  );
-  const extendedFieldApi = useMemo(() => {
-    const reactiveFieldApi = {
-      ...fieldApi,
-      get state() {
-        return {
-          // For array mode, reactiveStateValue is the length (for reactivity tracking),
-          // so we need to get the actual value from fieldApi
-          value: opts.mode === "array" ? fieldApi.state.value : reactiveStateValue,
-          get meta() {
-            return {
-              ...fieldApi.state.meta,
-              isTouched: reactiveMetaIsTouched,
-              isBlurred: reactiveMetaIsBlurred,
-              isDirty: reactiveMetaIsDirty,
-              errorMap: reactiveMetaErrorMap,
-              errorSourceMap: reactiveMetaErrorSourceMap,
-              isValidating: reactiveMetaIsValidating
-            };
-          }
-        };
-      }
-    };
-    const extendedApi = reactiveFieldApi;
-    extendedApi.Field = Field;
-    return extendedApi;
-  }, [
-    fieldApi,
-    opts.mode,
-    reactiveStateValue,
-    reactiveMetaIsTouched,
-    reactiveMetaIsBlurred,
-    reactiveMetaIsDirty,
-    reactiveMetaErrorMap,
-    reactiveMetaErrorSourceMap,
-    reactiveMetaIsValidating
-  ]);
-  useIsomorphicLayoutEffect(fieldApi.mount, [fieldApi]);
-  useIsomorphicLayoutEffect(() => {
-    fieldApi.update(opts);
-  });
-  return extendedFieldApi;
-}
-const Field = (({
-  children,
-  ...fieldOptions
-}) => {
-  const fieldApi = useField(fieldOptions);
-  const jsxToDisplay = useMemo(
-    () => functionalUpdate(children, fieldApi),
-    [children, fieldApi]
-  );
-  return /* @__PURE__ */ jsx(Fragment, { children: jsxToDisplay });
-});function useUUID() {
-  return useState(() => uuid())[0];
-}const useFormId = React.version.split(".")[0] === "17" ? useUUID : React.useId;function LocalSubscribe({
-  form,
-  selector,
-  children
-}) {
-  const data = useStore$1(form.store, selector);
-  return /* @__PURE__ */ jsx(Fragment, { children: functionalUpdate(children, data) });
-}
-function useForm(opts) {
-  const fallbackFormId = useFormId();
-  const [prevFormId, setPrevFormId] = useState(opts?.formId);
-  const [formApi, setFormApi] = useState(() => {
-    return new FormApi({ ...opts, formId: opts?.formId ?? fallbackFormId });
-  });
-  if (prevFormId !== opts?.formId) {
-    const formId = opts?.formId ?? fallbackFormId;
-    setFormApi(new FormApi({ ...opts, formId }));
-    setPrevFormId(formId);
+    $[0] = children;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
   }
-  const extendedFormApi = useMemo(() => {
-    const extendedApi = {
-      ...formApi,
-      handleSubmit: ((...props) => {
-        return formApi._handleSubmit(...props);
-      }),
-      // We must add all `get`ters from `core`'s `FormApi` here, as otherwise the spread operator won't catch those
-      get formId() {
-        return formApi._formId;
-      },
-      get state() {
-        return formApi.store.state;
-      }
-    };
-    extendedApi.Field = function APIField(props) {
-      return /* @__PURE__ */ jsx(Field, { ...props, form: formApi });
-    };
-    extendedApi.Subscribe = function Subscribe(props) {
-      return /* @__PURE__ */ jsx(
-        LocalSubscribe,
-        {
-          form: formApi,
-          selector: props.selector,
-          children: props.children
-        }
-      );
-    };
-    return extendedApi;
-  }, [formApi]);
-  useIsomorphicLayoutEffect(formApi.mount, []);
-  useIsomorphicLayoutEffect(() => {
-    formApi.update(opts);
-  });
-  return extendedFormApi;
+  return t1;
+};
+function _temp$1(e) {
+  e.preventDefault();
+  const form = e.currentTarget;
+  const submitButton = form.querySelector("button[type=\"submit\"]");
+  submitButton === null || submitButton === void 0 ? void 0 : submitButton.click();
 }/* eslint-disable @typescript-eslint/no-explicit-any */
 function useJotaiForm(formOptions) {
   const form = useForm(formOptions);
@@ -3056,956 +309,7 @@ function useJotaiForm(formOptions) {
   return jsx(FormFieldContainer, {
     children: config.component(baseProps)
   });
-};function hasInitialValue(atom) {
-  return "init" in atom;
-}
-function isActuallyWritableAtom(atom) {
-  return !!atom.write;
-}
-function isAtomStateInitialized(atomState) {
-  return "v" in atomState || "e" in atomState;
-}
-function returnAtomValue(atomState) {
-  if ("e" in atomState) {
-    throw atomState.e;
-  }
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("v" in atomState)) {
-    throw new Error("[Bug] atom state is not initialized");
-  }
-  return atomState.v;
-}
-const promiseStateMap = /* @__PURE__ */ new WeakMap();
-function isPendingPromise(value) {
-  var _a;
-  return isPromiseLike$1(value) && !!((_a = promiseStateMap.get(value)) == null ? void 0 : _a[0]);
-}
-function abortPromise(promise) {
-  const promiseState = promiseStateMap.get(promise);
-  if (promiseState == null ? void 0 : promiseState[0]) {
-    promiseState[0] = false;
-    promiseState[1].forEach((fn) => fn());
-  }
-}
-function registerAbortHandler(promise, abortHandler) {
-  let promiseState = promiseStateMap.get(promise);
-  if (!promiseState) {
-    promiseState = [true, /* @__PURE__ */ new Set()];
-    promiseStateMap.set(promise, promiseState);
-    const settle = () => {
-      promiseState[0] = false;
-    };
-    promise.then(settle, settle);
-  }
-  promiseState[1].add(abortHandler);
-}
-function isPromiseLike$1(p) {
-  return typeof (p == null ? void 0 : p.then) === "function";
-}
-function addPendingPromiseToDependency(atom, promise, dependencyAtomState) {
-  if (!dependencyAtomState.p.has(atom)) {
-    dependencyAtomState.p.add(atom);
-    const cleanup = () => dependencyAtomState.p.delete(atom);
-    promise.then(cleanup, cleanup);
-  }
-}
-function getMountedOrPendingDependents(atom, atomState, mountedMap) {
-  var _a;
-  const dependents = /* @__PURE__ */ new Set();
-  for (const a of ((_a = mountedMap.get(atom)) == null ? void 0 : _a.t) || []) {
-    dependents.add(a);
-  }
-  for (const atomWithPendingPromise of atomState.p) {
-    dependents.add(atomWithPendingPromise);
-  }
-  return dependents;
-}
-const BUILDING_BLOCK_atomRead = (_store, atom, ...params) => atom.read(...params);
-const BUILDING_BLOCK_atomWrite = (_store, atom, ...params) => atom.write(...params);
-const BUILDING_BLOCK_atomOnInit = (store, atom) => {
-  var _a;
-  return (_a = atom.INTERNAL_onInit) == null ? void 0 : _a.call(atom, store);
-};
-const BUILDING_BLOCK_atomOnMount = (_store, atom, setAtom) => {
-  var _a;
-  return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
-};
-const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
-  var _a;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const atomStateMap = buildingBlocks[0];
-  const storeHooks = buildingBlocks[6];
-  const atomOnInit = buildingBlocks[9];
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !atom) {
-    throw new Error("Atom is undefined or null");
-  }
-  let atomState = atomStateMap.get(atom);
-  if (!atomState) {
-    atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
-    atomStateMap.set(atom, atomState);
-    (_a = storeHooks.i) == null ? void 0 : _a.call(storeHooks, atom);
-    atomOnInit == null ? void 0 : atomOnInit(store, atom);
-  }
-  return atomState;
-};
-const BUILDING_BLOCK_flushCallbacks = (store) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const changedAtoms = buildingBlocks[3];
-  const mountCallbacks = buildingBlocks[4];
-  const unmountCallbacks = buildingBlocks[5];
-  const storeHooks = buildingBlocks[6];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const errors = [];
-  const call = (fn) => {
-    try {
-      fn();
-    } catch (e) {
-      errors.push(e);
-    }
-  };
-  do {
-    if (storeHooks.f) {
-      call(storeHooks.f);
-    }
-    const callbacks = /* @__PURE__ */ new Set();
-    const add = callbacks.add.bind(callbacks);
-    changedAtoms.forEach((atom) => {
-      var _a;
-      return (_a = mountedMap.get(atom)) == null ? void 0 : _a.l.forEach(add);
-    });
-    changedAtoms.clear();
-    unmountCallbacks.forEach(add);
-    unmountCallbacks.clear();
-    mountCallbacks.forEach(add);
-    mountCallbacks.clear();
-    callbacks.forEach(call);
-    if (changedAtoms.size) {
-      recomputeInvalidatedAtoms(store);
-    }
-  } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
-  if (errors.length) {
-    throw new AggregateError(errors);
-  }
-};
-const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const invalidatedAtoms = buildingBlocks[2];
-  const changedAtoms = buildingBlocks[3];
-  const ensureAtomState = buildingBlocks[11];
-  const readAtomState = buildingBlocks[14];
-  const mountDependencies = buildingBlocks[17];
-  const topSortedReversed = [];
-  const visiting = /* @__PURE__ */ new WeakSet();
-  const visited = /* @__PURE__ */ new WeakSet();
-  const stack = Array.from(changedAtoms);
-  while (stack.length) {
-    const a = stack[stack.length - 1];
-    const aState = ensureAtomState(store, a);
-    if (visited.has(a)) {
-      stack.pop();
-      continue;
-    }
-    if (visiting.has(a)) {
-      if (invalidatedAtoms.get(a) === aState.n) {
-        topSortedReversed.push([a, aState]);
-      } else if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && invalidatedAtoms.has(a)) {
-        throw new Error("[Bug] invalidated atom exists");
-      }
-      visited.add(a);
-      stack.pop();
-      continue;
-    }
-    visiting.add(a);
-    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      if (!visiting.has(d)) {
-        stack.push(d);
-      }
-    }
-  }
-  for (let i = topSortedReversed.length - 1; i >= 0; --i) {
-    const [a, aState] = topSortedReversed[i];
-    let hasChangedDeps = false;
-    for (const dep of aState.d.keys()) {
-      if (dep !== a && changedAtoms.has(dep)) {
-        hasChangedDeps = true;
-        break;
-      }
-    }
-    if (hasChangedDeps) {
-      readAtomState(store, a);
-      mountDependencies(store, a);
-    }
-    invalidatedAtoms.delete(a);
-  }
-};
-const storeMutationSet = /* @__PURE__ */ new WeakSet();
-const BUILDING_BLOCK_readAtomState = (store, atom) => {
-  var _a, _b;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const invalidatedAtoms = buildingBlocks[2];
-  const changedAtoms = buildingBlocks[3];
-  const storeHooks = buildingBlocks[6];
-  const atomRead = buildingBlocks[7];
-  const ensureAtomState = buildingBlocks[11];
-  const flushCallbacks = buildingBlocks[12];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const readAtomState = buildingBlocks[14];
-  const writeAtomState = buildingBlocks[16];
-  const mountDependencies = buildingBlocks[17];
-  const setAtomStateValueOrPromise = buildingBlocks[20];
-  const atomState = ensureAtomState(store, atom);
-  if (isAtomStateInitialized(atomState)) {
-    if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
-      return atomState;
-    }
-    let hasChangedDeps = false;
-    for (const [a, n] of atomState.d) {
-      if (readAtomState(store, a).n !== n) {
-        hasChangedDeps = true;
-        break;
-      }
-    }
-    if (!hasChangedDeps) {
-      return atomState;
-    }
-  }
-  atomState.d.clear();
-  let isSync = true;
-  function mountDependenciesIfAsync() {
-    if (mountedMap.has(atom)) {
-      mountDependencies(store, atom);
-      recomputeInvalidatedAtoms(store);
-      flushCallbacks(store);
-    }
-  }
-  function getter(a) {
-    var _a2;
-    if (a === atom) {
-      const aState2 = ensureAtomState(store, a);
-      if (!isAtomStateInitialized(aState2)) {
-        if (hasInitialValue(a)) {
-          setAtomStateValueOrPromise(store, a, a.init);
-        } else {
-          throw new Error("no atom init");
-        }
-      }
-      return returnAtomValue(aState2);
-    }
-    const aState = readAtomState(store, a);
-    try {
-      return returnAtomValue(aState);
-    } finally {
-      atomState.d.set(a, aState.n);
-      if (isPendingPromise(atomState.v)) {
-        addPendingPromiseToDependency(atom, atomState.v, aState);
-      }
-      if (mountedMap.has(atom)) {
-        (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom);
-      }
-      if (!isSync) {
-        mountDependenciesIfAsync();
-      }
-    }
-  }
-  let controller;
-  let setSelf;
-  const options = {
-    get signal() {
-      if (!controller) {
-        controller = new AbortController();
-      }
-      return controller.signal;
-    },
-    get setSelf() {
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-        console.warn(
-          "[DEPRECATED] setSelf is deprecated and will be removed in v3."
-        );
-      }
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
-        console.warn("setSelf function cannot be used with read-only atom");
-      }
-      if (!setSelf && isActuallyWritableAtom(atom)) {
-        setSelf = (...args) => {
-          if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && isSync) {
-            console.warn("setSelf function cannot be called in sync");
-          }
-          if (!isSync) {
-            try {
-              return writeAtomState(store, atom, ...args);
-            } finally {
-              recomputeInvalidatedAtoms(store);
-              flushCallbacks(store);
-            }
-          }
-        };
-      }
-      return setSelf;
-    }
-  };
-  const prevEpochNumber = atomState.n;
-  try {
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-      storeMutationSet.delete(store);
-    }
-    const valueOrPromise = atomRead(store, atom, getter, options);
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && storeMutationSet.has(store)) {
-      console.warn(
-        "Detected store mutation during atom read. This is not supported."
-      );
-    }
-    setAtomStateValueOrPromise(store, atom, valueOrPromise);
-    if (isPromiseLike$1(valueOrPromise)) {
-      registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
-      valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
-    }
-    (_a = storeHooks.r) == null ? void 0 : _a.call(storeHooks, atom);
-    return atomState;
-  } catch (error) {
-    delete atomState.v;
-    atomState.e = error;
-    ++atomState.n;
-    return atomState;
-  } finally {
-    isSync = false;
-    if (prevEpochNumber !== atomState.n && invalidatedAtoms.get(atom) === prevEpochNumber) {
-      invalidatedAtoms.set(atom, atomState.n);
-      changedAtoms.add(atom);
-      (_b = storeHooks.c) == null ? void 0 : _b.call(storeHooks, atom);
-    }
-  }
-};
-const BUILDING_BLOCK_invalidateDependents = (store, atom) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const invalidatedAtoms = buildingBlocks[2];
-  const ensureAtomState = buildingBlocks[11];
-  const stack = [atom];
-  while (stack.length) {
-    const a = stack.pop();
-    const aState = ensureAtomState(store, a);
-    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      const dState = ensureAtomState(store, d);
-      invalidatedAtoms.set(d, dState.n);
-      stack.push(d);
-    }
-  }
-};
-const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const changedAtoms = buildingBlocks[3];
-  const storeHooks = buildingBlocks[6];
-  const atomWrite = buildingBlocks[8];
-  const ensureAtomState = buildingBlocks[11];
-  const flushCallbacks = buildingBlocks[12];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const readAtomState = buildingBlocks[14];
-  const invalidateDependents = buildingBlocks[15];
-  const writeAtomState = buildingBlocks[16];
-  const mountDependencies = buildingBlocks[17];
-  const setAtomStateValueOrPromise = buildingBlocks[20];
-  let isSync = true;
-  const getter = (a) => returnAtomValue(readAtomState(store, a));
-  const setter = (a, ...args2) => {
-    var _a;
-    const aState = ensureAtomState(store, a);
-    try {
-      if (a === atom) {
-        if (!hasInitialValue(a)) {
-          throw new Error("atom not writable");
-        }
-        if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-          storeMutationSet.add(store);
-        }
-        const prevEpochNumber = aState.n;
-        const v = args2[0];
-        setAtomStateValueOrPromise(store, a, v);
-        mountDependencies(store, a);
-        if (prevEpochNumber !== aState.n) {
-          changedAtoms.add(a);
-          invalidateDependents(store, a);
-          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
-        }
-        return void 0;
-      } else {
-        return writeAtomState(store, a, ...args2);
-      }
-    } finally {
-      if (!isSync) {
-        recomputeInvalidatedAtoms(store);
-        flushCallbacks(store);
-      }
-    }
-  };
-  try {
-    return atomWrite(store, atom, getter, setter, ...args);
-  } finally {
-    isSync = false;
-  }
-};
-const BUILDING_BLOCK_mountDependencies = (store, atom) => {
-  var _a;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const changedAtoms = buildingBlocks[3];
-  const storeHooks = buildingBlocks[6];
-  const ensureAtomState = buildingBlocks[11];
-  const invalidateDependents = buildingBlocks[15];
-  const mountAtom = buildingBlocks[18];
-  const unmountAtom = buildingBlocks[19];
-  const atomState = ensureAtomState(store, atom);
-  const mounted = mountedMap.get(atom);
-  if (mounted && !isPendingPromise(atomState.v)) {
-    for (const [a, n] of atomState.d) {
-      if (!mounted.d.has(a)) {
-        const aState = ensureAtomState(store, a);
-        const aMounted = mountAtom(store, a);
-        aMounted.t.add(atom);
-        mounted.d.add(a);
-        if (n !== aState.n) {
-          changedAtoms.add(a);
-          invalidateDependents(store, a);
-          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
-        }
-      }
-    }
-    for (const a of mounted.d) {
-      if (!atomState.d.has(a)) {
-        mounted.d.delete(a);
-        const aMounted = unmountAtom(store, a);
-        aMounted == null ? void 0 : aMounted.t.delete(atom);
-      }
-    }
-  }
-};
-const BUILDING_BLOCK_mountAtom = (store, atom) => {
-  var _a;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const mountCallbacks = buildingBlocks[4];
-  const storeHooks = buildingBlocks[6];
-  const atomOnMount = buildingBlocks[10];
-  const ensureAtomState = buildingBlocks[11];
-  const flushCallbacks = buildingBlocks[12];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const readAtomState = buildingBlocks[14];
-  const writeAtomState = buildingBlocks[16];
-  const mountAtom = buildingBlocks[18];
-  const atomState = ensureAtomState(store, atom);
-  let mounted = mountedMap.get(atom);
-  if (!mounted) {
-    readAtomState(store, atom);
-    for (const a of atomState.d.keys()) {
-      const aMounted = mountAtom(store, a);
-      aMounted.t.add(atom);
-    }
-    mounted = {
-      l: /* @__PURE__ */ new Set(),
-      d: new Set(atomState.d.keys()),
-      t: /* @__PURE__ */ new Set()
-    };
-    mountedMap.set(atom, mounted);
-    if (isActuallyWritableAtom(atom)) {
-      const processOnMount = () => {
-        let isSync = true;
-        const setAtom = (...args) => {
-          try {
-            return writeAtomState(store, atom, ...args);
-          } finally {
-            if (!isSync) {
-              recomputeInvalidatedAtoms(store);
-              flushCallbacks(store);
-            }
-          }
-        };
-        try {
-          const onUnmount = atomOnMount(store, atom, setAtom);
-          if (onUnmount) {
-            mounted.u = () => {
-              isSync = true;
-              try {
-                onUnmount();
-              } finally {
-                isSync = false;
-              }
-            };
-          }
-        } finally {
-          isSync = false;
-        }
-      };
-      mountCallbacks.add(processOnMount);
-    }
-    (_a = storeHooks.m) == null ? void 0 : _a.call(storeHooks, atom);
-  }
-  return mounted;
-};
-const BUILDING_BLOCK_unmountAtom = (store, atom) => {
-  var _a, _b;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const unmountCallbacks = buildingBlocks[5];
-  const storeHooks = buildingBlocks[6];
-  const ensureAtomState = buildingBlocks[11];
-  const unmountAtom = buildingBlocks[19];
-  const atomState = ensureAtomState(store, atom);
-  let mounted = mountedMap.get(atom);
-  if (!mounted || mounted.l.size) {
-    return mounted;
-  }
-  let isDependent = false;
-  for (const a of mounted.t) {
-    if ((_a = mountedMap.get(a)) == null ? void 0 : _a.d.has(atom)) {
-      isDependent = true;
-      break;
-    }
-  }
-  if (!isDependent) {
-    if (mounted.u) {
-      unmountCallbacks.add(mounted.u);
-    }
-    mounted = void 0;
-    mountedMap.delete(atom);
-    for (const a of atomState.d.keys()) {
-      const aMounted = unmountAtom(store, a);
-      aMounted == null ? void 0 : aMounted.t.delete(atom);
-    }
-    (_b = storeHooks.u) == null ? void 0 : _b.call(storeHooks, atom);
-    return void 0;
-  }
-  return mounted;
-};
-const BUILDING_BLOCK_setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
-  const ensureAtomState = getInternalBuildingBlocks(store)[11];
-  const atomState = ensureAtomState(store, atom);
-  const hasPrevValue = "v" in atomState;
-  const prevValue = atomState.v;
-  if (isPromiseLike$1(valueOrPromise)) {
-    for (const a of atomState.d.keys()) {
-      addPendingPromiseToDependency(
-        atom,
-        valueOrPromise,
-        ensureAtomState(store, a)
-      );
-    }
-  }
-  atomState.v = valueOrPromise;
-  delete atomState.e;
-  if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
-    ++atomState.n;
-    if (isPromiseLike$1(prevValue)) {
-      abortPromise(prevValue);
-    }
-  }
-};
-const BUILDING_BLOCK_storeGet = (store, atom) => {
-  const readAtomState = getInternalBuildingBlocks(store)[14];
-  return returnAtomValue(readAtomState(store, atom));
-};
-const BUILDING_BLOCK_storeSet = (store, atom, ...args) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks = buildingBlocks[12];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const writeAtomState = buildingBlocks[16];
-  try {
-    return writeAtomState(store, atom, ...args);
-  } finally {
-    recomputeInvalidatedAtoms(store);
-    flushCallbacks(store);
-  }
-};
-const BUILDING_BLOCK_storeSub = (store, atom, listener) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks = buildingBlocks[12];
-  const mountAtom = buildingBlocks[18];
-  const unmountAtom = buildingBlocks[19];
-  const mounted = mountAtom(store, atom);
-  const listeners = mounted.l;
-  listeners.add(listener);
-  flushCallbacks(store);
-  return () => {
-    listeners.delete(listener);
-    unmountAtom(store, atom);
-    flushCallbacks(store);
-  };
-};
-const buildingBlockMap = /* @__PURE__ */ new WeakMap();
-const getInternalBuildingBlocks = (store) => {
-  const buildingBlocks = buildingBlockMap.get(store);
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !buildingBlocks) {
-    throw new Error(
-      "Store must be created by buildStore to read its building blocks"
-    );
-  }
-  return buildingBlocks;
-};
-function buildStore(...buildArgs) {
-  const store = {
-    get(atom) {
-      const storeGet = getInternalBuildingBlocks(store)[21];
-      return storeGet(store, atom);
-    },
-    set(atom, ...args) {
-      const storeSet = getInternalBuildingBlocks(store)[22];
-      return storeSet(store, atom, ...args);
-    },
-    sub(atom, listener) {
-      const storeSub = getInternalBuildingBlocks(store)[23];
-      return storeSub(store, atom, listener);
-    }
-  };
-  const buildingBlocks = [
-    // store state
-    /* @__PURE__ */ new WeakMap(),
-    // atomStateMap
-    /* @__PURE__ */ new WeakMap(),
-    // mountedMap
-    /* @__PURE__ */ new WeakMap(),
-    // invalidatedAtoms
-    /* @__PURE__ */ new Set(),
-    // changedAtoms
-    /* @__PURE__ */ new Set(),
-    // mountCallbacks
-    /* @__PURE__ */ new Set(),
-    // unmountCallbacks
-    {},
-    // storeHooks
-    // atom interceptors
-    BUILDING_BLOCK_atomRead,
-    BUILDING_BLOCK_atomWrite,
-    BUILDING_BLOCK_atomOnInit,
-    BUILDING_BLOCK_atomOnMount,
-    // building-block functions
-    BUILDING_BLOCK_ensureAtomState,
-    BUILDING_BLOCK_flushCallbacks,
-    BUILDING_BLOCK_recomputeInvalidatedAtoms,
-    BUILDING_BLOCK_readAtomState,
-    BUILDING_BLOCK_invalidateDependents,
-    BUILDING_BLOCK_writeAtomState,
-    BUILDING_BLOCK_mountDependencies,
-    BUILDING_BLOCK_mountAtom,
-    BUILDING_BLOCK_unmountAtom,
-    BUILDING_BLOCK_setAtomStateValueOrPromise,
-    BUILDING_BLOCK_storeGet,
-    BUILDING_BLOCK_storeSet,
-    BUILDING_BLOCK_storeSub,
-    void 0
-  ].map((fn, i) => buildArgs[i] || fn);
-  buildingBlockMap.set(store, Object.freeze(buildingBlocks));
-  return store;
-}let keyCount = 0;
-function atom(read, write) {
-  const key = `atom${++keyCount}`;
-  const config = {
-    toString() {
-      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
-    }
-  };
-  if (typeof read === "function") {
-    config.read = read;
-  } else {
-    config.init = read;
-    config.read = defaultRead;
-    config.write = defaultWrite;
-  }
-  if (write) {
-    config.write = write;
-  }
-  return config;
-}
-function defaultRead(get) {
-  return get(this);
-}
-function defaultWrite(get, set, arg) {
-  return set(
-    this,
-    typeof arg === "function" ? arg(get(this)) : arg
-  );
-}
-function createStore() {
-  return buildStore();
-}
-let defaultStore;
-function getDefaultStore() {
-  if (!defaultStore) {
-    defaultStore = createStore();
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-      globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
-      if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
-        console.warn(
-          "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
-        );
-      }
-    }
-  }
-  return defaultStore;
-}const StoreContext = createContext(
-  void 0
-);
-function useStore(options) {
-  const store = useContext(StoreContext);
-  return store || getDefaultStore();
-}
-
-const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
-const attachPromiseStatus = (promise) => {
-  if (!promise.status) {
-    promise.status = "pending";
-    promise.then(
-      (v) => {
-        promise.status = "fulfilled";
-        promise.value = v;
-      },
-      (e) => {
-        promise.status = "rejected";
-        promise.reason = e;
-      }
-    );
-  }
-};
-const use = React__default.use || // A shim for older React versions
-((promise) => {
-  if (promise.status === "pending") {
-    throw promise;
-  } else if (promise.status === "fulfilled") {
-    return promise.value;
-  } else if (promise.status === "rejected") {
-    throw promise.reason;
-  } else {
-    attachPromiseStatus(promise);
-    throw promise;
-  }
-});
-const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
-const createContinuablePromise = (promise, getValue) => {
-  let continuablePromise = continuablePromiseMap.get(promise);
-  if (!continuablePromise) {
-    continuablePromise = new Promise((resolve, reject) => {
-      let curr = promise;
-      const onFulfilled = (me) => (v) => {
-        if (curr === me) {
-          resolve(v);
-        }
-      };
-      const onRejected = (me) => (e) => {
-        if (curr === me) {
-          reject(e);
-        }
-      };
-      const onAbort = () => {
-        try {
-          const nextValue = getValue();
-          if (isPromiseLike(nextValue)) {
-            continuablePromiseMap.set(nextValue, continuablePromise);
-            curr = nextValue;
-            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
-            registerAbortHandler(nextValue, onAbort);
-          } else {
-            resolve(nextValue);
-          }
-        } catch (e) {
-          reject(e);
-        }
-      };
-      promise.then(onFulfilled(promise), onRejected(promise));
-      registerAbortHandler(promise, onAbort);
-    });
-    continuablePromiseMap.set(promise, continuablePromise);
-  }
-  return continuablePromise;
-};
-function useAtomValue(atom, options) {
-  const { delay, unstable_promiseStatus: promiseStatus = !React__default.use } = {};
-  const store = useStore();
-  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(
-    (prev) => {
-      const nextValue = store.get(atom);
-      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
-        return prev;
-      }
-      return [nextValue, store, atom];
-    },
-    void 0,
-    () => [store.get(atom), store, atom]
-  );
-  let value = valueFromReducer;
-  if (storeFromReducer !== store || atomFromReducer !== atom) {
-    rerender();
-    value = store.get(atom);
-  }
-  useEffect(() => {
-    const unsub = store.sub(atom, () => {
-      if (promiseStatus) {
-        try {
-          const value2 = store.get(atom);
-          if (isPromiseLike(value2)) {
-            attachPromiseStatus(
-              createContinuablePromise(value2, () => store.get(atom))
-            );
-          }
-        } catch (e) {
-        }
-      }
-      if (typeof delay === "number") {
-        setTimeout(rerender, delay);
-        return;
-      }
-      rerender();
-    });
-    rerender();
-    return unsub;
-  }, [store, atom, delay, promiseStatus]);
-  useDebugValue(value);
-  if (isPromiseLike(value)) {
-    const promise = createContinuablePromise(value, () => store.get(atom));
-    if (promiseStatus) {
-      attachPromiseStatus(promise);
-    }
-    return use(promise);
-  }
-  return value;
-}
-
-function useSetAtom(atom, options) {
-  const store = useStore();
-  const setAtom = useCallback(
-    (...args) => {
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("write" in atom)) {
-        throw new Error("not writable atom");
-      }
-      return store.set(atom, ...args);
-    },
-    [store, atom]
-  );
-  return setAtom;
-}
-
-function useAtom(atom, options) {
-  return [
-    useAtomValue(atom),
-    // We do wrong type assertion here, which results in throwing an error.
-    useSetAtom(atom)
-  ];
-}const getCached$2 = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);
-const cache1$3 = /* @__PURE__ */ new WeakMap();
-const memo3 = (create, dep1, dep2, dep3) => {
-  const cache2 = getCached$2(() => /* @__PURE__ */ new WeakMap(), cache1$3, dep1);
-  const cache3 = getCached$2(() => /* @__PURE__ */ new WeakMap(), cache2, dep2);
-  return getCached$2(create, cache3, dep3);
-};
-function selectAtom(anAtom, selector, equalityFn = Object.is) {
-  return memo3(
-    () => {
-      const EMPTY = /* @__PURE__ */ Symbol();
-      const selectValue = ([value, prevSlice]) => {
-        if (prevSlice === EMPTY) {
-          return selector(value);
-        }
-        const slice = selector(value, prevSlice);
-        return equalityFn(prevSlice, slice) ? prevSlice : slice;
-      };
-      const derivedAtom = atom((get) => {
-        const prev = get(derivedAtom);
-        const value = get(anAtom);
-        return selectValue([value, prev]);
-      });
-      derivedAtom.init = EMPTY;
-      return derivedAtom;
-    },
-    anAtom,
-    selector,
-    equalityFn
-  );
-}
-
-const isPromiseLike$2 = (x) => typeof (x == null ? void 0 : x.then) === "function";
-function createJSONStorage(getStringStorage = () => {
-  try {
-    return window.localStorage;
-  } catch (e) {
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-      if (typeof window !== "undefined") {
-        console.warn(e);
-      }
-    }
-    return void 0;
-  }
-}, options) {
-  var _a;
-  let lastStr;
-  let lastValue;
-  const storage = {
-    getItem: (key, initialValue) => {
-      var _a2, _b;
-      const parse = (str2) => {
-        str2 = str2 || "";
-        if (lastStr !== str2) {
-          try {
-            lastValue = JSON.parse(str2, void 0 );
-          } catch (e) {
-            return initialValue;
-          }
-          lastStr = str2;
-        }
-        return lastValue;
-      };
-      const str = (_b = (_a2 = getStringStorage()) == null ? void 0 : _a2.getItem(key)) != null ? _b : null;
-      if (isPromiseLike$2(str)) {
-        return str.then(parse);
-      }
-      return parse(str);
-    },
-    setItem: (key, newValue) => {
-      var _a2;
-      return (_a2 = getStringStorage()) == null ? void 0 : _a2.setItem(
-        key,
-        JSON.stringify(newValue, void 0 )
-      );
-    },
-    removeItem: (key) => {
-      var _a2;
-      return (_a2 = getStringStorage()) == null ? void 0 : _a2.removeItem(key);
-    }
-  };
-  const createHandleSubscribe = (subscriber2) => (key, callback, initialValue) => subscriber2(key, (v) => {
-    let newValue;
-    try {
-      newValue = JSON.parse(v || "");
-    } catch (e) {
-      newValue = initialValue;
-    }
-    callback(newValue);
-  });
-  let subscriber;
-  try {
-    subscriber = (_a = getStringStorage()) == null ? void 0 : _a.subscribe;
-  } catch (e) {
-  }
-  if (!subscriber && typeof window !== "undefined" && typeof window.addEventListener === "function" && window.Storage) {
-    subscriber = (key, callback) => {
-      if (!(getStringStorage() instanceof window.Storage)) {
-        return () => {
-        };
-      }
-      const storageEventCallback = (e) => {
-        if (e.storageArea === getStringStorage() && e.key === key) {
-          callback(e.newValue);
-        }
-      };
-      window.addEventListener("storage", storageEventCallback);
-      return () => {
-        window.removeEventListener("storage", storageEventCallback);
-      };
-    };
-  }
-  if (subscriber) {
-    storage.subscribe = createHandleSubscribe(subscriber);
-  }
-  return storage;
-}
-createJSONStorage();const DEFAULT_FORM_ENTRY = Object.freeze({
+};const DEFAULT_FORM_ENTRY = Object.freeze({
   formValues: {},
   setValue: () => {}
 });