@gaddario98/react-core 2.0.0 → 2.0.2

package/dist/form/index.js

@@ -1 +1,4566 @@
-'use strict';var reactForm=require('@gaddario98/react-form');Object.keys(reactForm).forEach(function(k){if(k!=='default'&&!Object.prototype.hasOwnProperty.call(exports,k))Object.defineProperty(exports,k,{enumerable:true,get:function(){return reactForm[k]}})});//# sourceMappingURL=index.js.map
+'use strict';var reactState=require('@gaddario98/react-state'),compilerRuntime=require('react/compiler-runtime'),jsxRuntime=require('react/jsx-runtime'),React=require('react'),equal=require('fast-deep-equal'),withSelector_js=require('use-sync-external-store/shim/with-selector.js');function _interopNamespaceDefault(e){var n=Object.create(null);if(e){Object.keys(e).forEach(function(k){if(k!=='default'){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}});}})}n.default=e;return Object.freeze(n)}var React__namespace=/*#__PURE__*/_interopNamespaceDefault(React);const DefaultContainer = ({
+  children
+}) => {
+  return children;
+};
+// Lazy initialization to avoid side effects at module load time
+const _formConfig = {
+  formFieldContainer: DefaultContainer
+};
+const {
+  atom: formConfigAtom,
+  useValue: useFormConfigValue,
+  useState: useFormConfigState,
+  useReset: useFormConfigReset
+} = reactState.atomStateGenerator({
+  key: 'formConfig',
+  defaultValue: _formConfig,
+  persist: false
+});const createDefaultContainer = () => {
+  return ({
+    children
+  }) => {
+    return children;
+  };
+};
+exports.DefaultContainer = createDefaultContainer();
+const setDefaultFormContainer = val => {
+  exports.DefaultContainer = val;
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const DefaultFormContainer = t0 => {
+  const $ = compilerRuntime.c(2);
+  const {
+    children
+  } = t0;
+  const handleSubmit = _temp$1;
+  let t1;
+  if ($[0] !== children) {
+    t1 = jsxRuntime.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);
+        }
+      }
+    }
+  }
+}//#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);
+        }
+      }
+    };
+    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();
+  };
+  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
+      });
+      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();
+      }
+      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();
+      }
+      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);
+      }
+      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 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);
+    }
+    const key = path.shift();
+    if (typeof key === "string" || typeof key === "number" && !Array.isArray(parent)) {
+      if (typeof parent === "object") {
+        if (parent === null) {
+          parent = {};
+        }
+        return {
+          ...parent,
+          [key]: doSet(parent[key])
+        };
+      }
+      return {
+        [key]: doSet()
+      };
+    }
+    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 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
+  };
+};
+const determineFieldLevelErrorSourceAndValue = ({
+  formLevelError,
+  fieldLevelError
+}) => {
+  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);
+  }
+};
+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: {}
+};
+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) return [];
+      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 = withSelector_js.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" ? React.useLayoutEffect : React.useEffect;function useField(opts) {
+  const [prevOptions, setPrevOptions] = React.useState(() => ({
+    form: opts.form,
+    name: opts.name
+  }));
+  const [fieldApi, setFieldApi] = React.useState(() => {
+    return new FieldApi({
+      ...opts
+    });
+  });
+  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 = React.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 = React.useMemo(
+    () => functionalUpdate(children, fieldApi),
+    [children, fieldApi]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: jsxToDisplay });
+});function useUUID() {
+  return React.useState(() => uuid())[0];
+}const useFormId = React__namespace.version.split(".")[0] === "17" ? useUUID : React__namespace.useId;function LocalSubscribe({
+  form,
+  selector,
+  children
+}) {
+  const data = useStore$1(form.store, selector);
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: functionalUpdate(children, data) });
+}
+function useForm(opts) {
+  const fallbackFormId = useFormId();
+  const [prevFormId, setPrevFormId] = React.useState(opts?.formId);
+  const [formApi, setFormApi] = React.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);
+  }
+  const extendedFormApi = React.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__ */ jsxRuntime.jsx(Field, { ...props, form: formApi });
+    };
+    extendedApi.Subscribe = function Subscribe(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        LocalSubscribe,
+        {
+          form: formApi,
+          selector: props.selector,
+          children: props.children
+        }
+      );
+    };
+    return extendedApi;
+  }, [formApi]);
+  useIsomorphicLayoutEffect(formApi.mount, []);
+  useIsomorphicLayoutEffect(() => {
+    formApi.update(opts);
+  });
+  return extendedFormApi;
+}/* eslint-disable @typescript-eslint/no-explicit-any */
+function useJotaiForm(formOptions) {
+  const form = useForm(formOptions);
+  return form;
+}const FormField = ({
+  config,
+  onFieldChange,
+  ns: globalNs,
+  globalErrorNs
+}) => {
+  var _a, _b;
+  const ns = (_a = config.ns) !== null && _a !== void 0 ? _a : globalNs;
+  const errorNs = (_b = config.errorNs) !== null && _b !== void 0 ? _b : globalErrorNs;
+  const {
+    formFieldContainer,
+    translateText
+  } = useFormConfigValue();
+  // TanStack Form uses field.state.meta.errors which is an array of ValidationError
+  const firstError = config.field.state.meta.errors.length > 0 ? config.field.state.meta.errors[0] : undefined;
+  const errorMessageStr = firstError ? String(firstError) : undefined;
+  const errorMessage = React.useMemo(() => {
+    if (!errorMessageStr) return undefined;
+    return errorNs ? translateText === null || translateText === void 0 ? void 0 : translateText(errorMessageStr, {
+      ns: errorNs || '',
+      defaultValue: ''
+    }) : errorMessageStr;
+  }, [errorMessageStr, errorNs, translateText]);
+  const label = React.useMemo(() => {
+    var _a_0;
+    return ns ? translateText === null || translateText === void 0 ? void 0 : translateText((_a_0 = config.label) !== null && _a_0 !== void 0 ? _a_0 : '') : config.label;
+  }, [ns, config.label, translateText]);
+  const helperMessage = React.useMemo(() => {
+    var _a_1;
+    return ((_a_1 = config.helper) === null || _a_1 === void 0 ? void 0 : _a_1.text) ? translateText === null || translateText === void 0 ? void 0 : translateText(config.helper.text, config.helper.translationOption) : '';
+  }, [config.helper, translateText]);
+  const ref = React.useRef({
+    onFieldChange,
+    handleChange: config.field.handleChange
+  });
+  React.useEffect(() => {
+    ref.current = {
+      onFieldChange,
+      handleChange: config.field.handleChange
+    };
+  }, [config.field.handleChange, onFieldChange]);
+  const handleChange = React.useCallback(value => {
+    var _a_2, _b_0;
+    // TanStack Form handleChange usually expects just the value for input
+    // but if we are manually calling it we should pass the value.
+    ref.current.handleChange(value);
+    (_b_0 = (_a_2 = ref.current).onFieldChange) === null || _b_0 === void 0 ? void 0 : _b_0.call(_a_2, value);
+  }, []);
+  const handleBlur = React.useCallback(() => {
+    config.field.handleBlur();
+  }, [config.field]);
+  const baseProps = React.useMemo(() => ({
+    value: config.field.state.value,
+    onChange: handleChange,
+    onBlur: handleBlur,
+    error: config.field.state.meta.errors.length > 0,
+    errorMessage,
+    label,
+    helperMessage
+  }), [config.field.state.value, handleChange, handleBlur, config.field.state.meta.errors.length, errorMessage, label, helperMessage]);
+  const ConfigContainer = React.useMemo(() => config.container, [config.container]);
+  const FormFieldContainer = React.useMemo(() => formFieldContainer, [formFieldContainer]);
+  if (ConfigContainer) {
+    return jsxRuntime.jsx(ConfigContainer, {
+      children: config.component(baseProps)
+    });
+  }
+  return jsxRuntime.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 ((undefined ? undefined.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 atomRead = (_store, atom, ...params) => atom.read(...params);
+const atomWrite = (_store, atom, ...params) => atom.write(...params);
+const atomOnInit = (store, atom) => {
+  if (atom.INTERNAL_onInit) {
+    return atom.INTERNAL_onInit(store);
+  }
+  if (atom.unstable_onInit) {
+    console.warn(
+      "[DEPRECATED] atom.unstable_onInit is renamed to atom.INTERNAL_onInit."
+    );
+    return atom.unstable_onInit(store);
+  }
+};
+const atomOnMount = (_store, atom, setAtom) => {
+  var _a;
+  return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
+};
+const ensureAtomState = (store, atom) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const atomStateMap = buildingBlocks[0];
+  const storeHooks = buildingBlocks[6];
+  const atomOnInit2 = buildingBlocks[9];
+  if ((undefined ? undefined.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);
+    atomOnInit2 == null ? void 0 : atomOnInit2(store, atom);
+  }
+  return atomState;
+};
+const 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 recomputeInvalidatedAtoms2 = 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) {
+      recomputeInvalidatedAtoms2(store);
+    }
+  } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
+  if (errors.length) {
+    throw new AggregateError(errors);
+  }
+};
+const recomputeInvalidatedAtoms = (store) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const invalidatedAtoms = buildingBlocks[2];
+  const changedAtoms = buildingBlocks[3];
+  const ensureAtomState2 = buildingBlocks[11];
+  const readAtomState2 = buildingBlocks[14];
+  const mountDependencies2 = 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 = ensureAtomState2(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 ((undefined ? undefined.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) {
+      readAtomState2(store, a);
+      mountDependencies2(store, a);
+    }
+    invalidatedAtoms.delete(a);
+  }
+};
+const storeMutationSet = /* @__PURE__ */ new WeakSet();
+const 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 atomRead2 = buildingBlocks[7];
+  const ensureAtomState2 = buildingBlocks[11];
+  const flushCallbacks2 = buildingBlocks[12];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const readAtomState2 = buildingBlocks[14];
+  const writeAtomState2 = buildingBlocks[16];
+  const mountDependencies2 = buildingBlocks[17];
+  const atomState = ensureAtomState2(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 (readAtomState2(store, a).n !== n) {
+        hasChangedDeps = true;
+        break;
+      }
+    }
+    if (!hasChangedDeps) {
+      return atomState;
+    }
+  }
+  atomState.d.clear();
+  let isSync = true;
+  function mountDependenciesIfAsync() {
+    if (mountedMap.has(atom)) {
+      mountDependencies2(store, atom);
+      recomputeInvalidatedAtoms2(store);
+      flushCallbacks2(store);
+    }
+  }
+  function getter(a) {
+    var _a2;
+    if (a === atom) {
+      const aState2 = ensureAtomState2(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 = readAtomState2(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 ((undefined ? undefined.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
+        console.warn("setSelf function cannot be used with read-only atom");
+      }
+      if (!setSelf && isActuallyWritableAtom(atom)) {
+        setSelf = (...args) => {
+          if ((undefined ? undefined.MODE : void 0) !== "production" && isSync) {
+            console.warn("setSelf function cannot be called in sync");
+          }
+          if (!isSync) {
+            try {
+              return writeAtomState2(store, atom, ...args);
+            } finally {
+              recomputeInvalidatedAtoms2(store);
+              flushCallbacks2(store);
+            }
+          }
+        };
+      }
+      return setSelf;
+    }
+  };
+  const prevEpochNumber = atomState.n;
+  try {
+    if ((undefined ? undefined.MODE : void 0) !== "production") {
+      storeMutationSet.delete(store);
+    }
+    const valueOrPromise = atomRead2(store, atom, getter, options);
+    if ((undefined ? undefined.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 invalidateDependents = (store, atom) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const invalidatedAtoms = buildingBlocks[2];
+  const ensureAtomState2 = buildingBlocks[11];
+  const stack = [atom];
+  while (stack.length) {
+    const a = stack.pop();
+    const aState = ensureAtomState2(store, a);
+    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+      const dState = ensureAtomState2(store, d);
+      invalidatedAtoms.set(d, dState.n);
+      stack.push(d);
+    }
+  }
+};
+const writeAtomState = (store, atom, ...args) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const changedAtoms = buildingBlocks[3];
+  const storeHooks = buildingBlocks[6];
+  const atomWrite2 = buildingBlocks[8];
+  const ensureAtomState2 = buildingBlocks[11];
+  const flushCallbacks2 = buildingBlocks[12];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const readAtomState2 = buildingBlocks[14];
+  const invalidateDependents2 = buildingBlocks[15];
+  const mountDependencies2 = buildingBlocks[17];
+  let isSync = true;
+  const getter = (a) => returnAtomValue(readAtomState2(store, a));
+  const setter = (a, ...args2) => {
+    var _a;
+    const aState = ensureAtomState2(store, a);
+    try {
+      if (a === atom) {
+        if (!hasInitialValue(a)) {
+          throw new Error("atom not writable");
+        }
+        if ((undefined ? undefined.MODE : void 0) !== "production") {
+          storeMutationSet.add(store);
+        }
+        const prevEpochNumber = aState.n;
+        const v = args2[0];
+        setAtomStateValueOrPromise(store, a, v);
+        mountDependencies2(store, a);
+        if (prevEpochNumber !== aState.n) {
+          changedAtoms.add(a);
+          invalidateDependents2(store, a);
+          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
+        }
+        return void 0;
+      } else {
+        return writeAtomState(store, a, ...args2);
+      }
+    } finally {
+      if (!isSync) {
+        recomputeInvalidatedAtoms2(store);
+        flushCallbacks2(store);
+      }
+    }
+  };
+  try {
+    return atomWrite2(store, atom, getter, setter, ...args);
+  } finally {
+    isSync = false;
+  }
+};
+const mountDependencies = (store, atom) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const changedAtoms = buildingBlocks[3];
+  const storeHooks = buildingBlocks[6];
+  const ensureAtomState2 = buildingBlocks[11];
+  const invalidateDependents2 = buildingBlocks[15];
+  const mountAtom2 = buildingBlocks[18];
+  const unmountAtom2 = buildingBlocks[19];
+  const atomState = ensureAtomState2(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 = ensureAtomState2(store, a);
+        const aMounted = mountAtom2(store, a);
+        aMounted.t.add(atom);
+        mounted.d.add(a);
+        if (n !== aState.n) {
+          changedAtoms.add(a);
+          invalidateDependents2(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 = unmountAtom2(store, a);
+        aMounted == null ? void 0 : aMounted.t.delete(atom);
+      }
+    }
+  }
+};
+const mountAtom = (store, atom) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const mountCallbacks = buildingBlocks[4];
+  const storeHooks = buildingBlocks[6];
+  const atomOnMount2 = buildingBlocks[10];
+  const ensureAtomState2 = buildingBlocks[11];
+  const flushCallbacks2 = buildingBlocks[12];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const readAtomState2 = buildingBlocks[14];
+  const writeAtomState2 = buildingBlocks[16];
+  const atomState = ensureAtomState2(store, atom);
+  let mounted = mountedMap.get(atom);
+  if (!mounted) {
+    readAtomState2(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 writeAtomState2(store, atom, ...args);
+          } finally {
+            if (!isSync) {
+              recomputeInvalidatedAtoms2(store);
+              flushCallbacks2(store);
+            }
+          }
+        };
+        try {
+          const onUnmount = atomOnMount2(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 unmountAtom = (store, atom) => {
+  var _a, _b;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const unmountCallbacks = buildingBlocks[5];
+  const storeHooks = buildingBlocks[6];
+  const ensureAtomState2 = buildingBlocks[11];
+  const unmountAtom2 = buildingBlocks[19];
+  const atomState = ensureAtomState2(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 = unmountAtom2(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 setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
+  const ensureAtomState2 = getInternalBuildingBlocks(store)[11];
+  const atomState = ensureAtomState2(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,
+        ensureAtomState2(store, a)
+      );
+    }
+  }
+  atomState.v = valueOrPromise;
+  delete atomState.e;
+  if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
+    ++atomState.n;
+    if (isPromiseLike$1(prevValue)) {
+      abortPromise(prevValue);
+    }
+  }
+};
+const storeGet = (store, atom) => {
+  const readAtomState2 = getInternalBuildingBlocks(store)[14];
+  return returnAtomValue(readAtomState2(store, atom));
+};
+const storeSet = (store, atom, ...args) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const flushCallbacks2 = buildingBlocks[12];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const writeAtomState2 = buildingBlocks[16];
+  try {
+    return writeAtomState2(store, atom, ...args);
+  } finally {
+    recomputeInvalidatedAtoms2(store);
+    flushCallbacks2(store);
+  }
+};
+const storeSub = (store, atom, listener) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const flushCallbacks2 = buildingBlocks[12];
+  const mountAtom2 = buildingBlocks[18];
+  const unmountAtom2 = buildingBlocks[19];
+  const mounted = mountAtom2(store, atom);
+  const listeners = mounted.l;
+  listeners.add(listener);
+  flushCallbacks2(store);
+  return () => {
+    listeners.delete(listener);
+    unmountAtom2(store, atom);
+    flushCallbacks2(store);
+  };
+};
+const buildingBlockMap = /* @__PURE__ */ new WeakMap();
+const getInternalBuildingBlocks = (store) => {
+  const buildingBlocks = buildingBlockMap.get(store);
+  if ((undefined ? undefined.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 storeGet2 = getInternalBuildingBlocks(store)[21];
+      return storeGet2(store, atom);
+    },
+    set(atom, ...args) {
+      const storeSet2 = getInternalBuildingBlocks(store)[22];
+      return storeSet2(store, atom, ...args);
+    },
+    sub(atom, listener) {
+      const storeSub2 = getInternalBuildingBlocks(store)[23];
+      return storeSub2(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
+    atomRead,
+    atomWrite,
+    atomOnInit,
+    atomOnMount,
+    // building-block functions
+    ensureAtomState,
+    flushCallbacks,
+    recomputeInvalidatedAtoms,
+    readAtomState,
+    invalidateDependents,
+    writeAtomState,
+    mountDependencies,
+    mountAtom,
+    unmountAtom,
+    setAtomStateValueOrPromise,
+    storeGet,
+    storeSet,
+    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 (undefined ? undefined.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 ((undefined ? undefined.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 = React.createContext(
+  void 0
+);
+function useStore(options) {
+  const store = React.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.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.use } = {};
+  const store = useStore();
+  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = React.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);
+  }
+  React.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]);
+  React.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 = React.useCallback(
+    (...args) => {
+      if ((undefined ? undefined.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$3 = (x) => typeof (x == null ? void 0 : x.then) === "function";
+function createJSONStorage(getStringStorage = () => {
+  try {
+    return window.localStorage;
+  } catch (e) {
+    if ((undefined ? undefined.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$3(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({
+  formValues: {},
+  setValue: () => {}
+});
+/**
+ * Global atom storing all form state.
+ * Key format: "scopeId:formId" or just "formId" for backward compatibility.
+ */
+const formAtom = atom({});
+/**
+ * Helper to generate composite keys for forms.
+ */
+const getFormCompositeKey = (scopeId, key) => `${scopeId}:${key}`;
+/**
+ * Creates a derived atom for accessing forms of a specific scope.
+ */
+const createScopeFormsAtom = scopeId => atom(get => {
+  const allForms = get(formAtom);
+  const prefix = `${scopeId}:`;
+  const scopeForms = {};
+  for (const [key, value] of Object.entries(allForms)) {
+    if (key.startsWith(prefix)) {
+      scopeForms[key.slice(prefix.length)] = value;
+    }
+  }
+  return scopeForms;
+}, (get, set, update) => {
+  const allForms = get(formAtom);
+  const prefix = `${scopeId}:`;
+  const newForms = Object.assign({}, allForms);
+  // Remove old scope entries
+  for (const key of Object.keys(newForms)) {
+    if (key.startsWith(prefix)) {
+      delete newForms[key];
+    }
+  }
+  // Add new scope entries
+  for (const [key, value] of Object.entries(update)) {
+    newForms[`${prefix}${key}`] = value;
+  }
+  set(formAtom, newForms);
+});
+const createFormSelector = formId => selectAtom(formAtom, forms => {
+  const entry = forms[formId];
+  return entry !== null && entry !== void 0 ? entry : DEFAULT_FORM_ENTRY;
+}, (a, b) => a === b || a.formValues === b.formValues && a.setValue === b.setValue);
+const useFormValue = formId => {
+  const $ = compilerRuntime.c(2);
+  let t0;
+  if ($[0] !== formId) {
+    t0 = createFormSelector(formId);
+    $[0] = formId;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const selectorAtom = t0;
+  return useAtomValue(selectorAtom);
+};
+const useFormState = () => {
+  return useAtom(formAtom);
+};
+const useSetFormState = formId => {
+  const setForms = useSetAtom(formAtom);
+  return React.useCallback(val => {
+    setForms(prev => {
+      var _a;
+      const prevEntry = (_a = prev[formId]) !== null && _a !== void 0 ? _a : DEFAULT_FORM_ENTRY;
+      return Object.assign(Object.assign({}, prev), {
+        [formId]: Object.assign(Object.assign({}, prevEntry), val)
+      });
+    });
+  }, [formId, setForms]);
+};const getValueAtPath = (obj, path, defaultObj) => {
+  if (!path) return undefined;
+  const normalized = path.replace(/\[(\d+)\]/g, '.$1');
+  const parts = normalized.split('.').filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (!current || !Object.keys(current).length) {
+      return undefined;
+    }
+    if (typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current;
+};
+const useFormValues = ({
+  formId
+}) => {
+  // We subscribe to the specific form entry in the atoms
+  // Note: This subscription is a bit coarse (entire form entry), but we optimize re-renders locally
+  // Ideally we would want to subscribe only to specific paths, but Jotai atoms are per-form.
+  const formEntry = useFormValue(formId);
+  const currentValues = React.useMemo(() => formEntry.formValues, [formEntry.formValues]);
+  const subscriptions = React.useRef(new Map());
+  // trigger state is used to force re-render when a subscribed value changes
+  const [trigger, setTrigger] = React.useState(0);
+  // Ref to hold the latest values without causing re-renders itself
+  const formRef = React.useRef({
+    formValues: formEntry.formValues,
+    setValue: formEntry.setValue
+  });
+  React.useEffect(() => {
+    formRef.current.setValue = formEntry.setValue;
+  }, [formEntry.setValue]);
+  React.useEffect(() => {
+    let shouldTrigger = false;
+    subscriptions.current.forEach((_, path) => {
+      const newValue = getValueAtPath(currentValues, path);
+      const oldValue = getValueAtPath(formRef.current.formValues, path);
+      if (!equal(newValue, oldValue)) {
+        shouldTrigger = true;
+      }
+    });
+    formRef.current.formValues = currentValues;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (shouldTrigger) {
+      setTrigger(c => c + 1);
+    }
+  }, [currentValues]);
+  const get = React.useCallback((key, defaultValue) => {
+    var _a;
+    const val = (_a = getValueAtPath(formRef.current.formValues, key)) !== null && _a !== void 0 ? _a : defaultValue;
+    subscriptions.current.set(key, val);
+    return subscriptions.current.get(key);
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [trigger]);
+  const set = React.useCallback((field, value) => {
+    formRef.current.setValue(field, value);
+  }, []);
+  return {
+    get,
+    set
+  };
+};const trimObject = obj => Object.entries(obj !== null && obj !== void 0 ? obj : {}).reduce((prev, [key, val]) => Object.assign(Object.assign({}, prev), {
+  [key]: typeof val === 'string' && !['password', 'pPassword'].includes(key) ? val.trim() : val
+}), {});
+const RenderField = t0 => {
+  const $ = compilerRuntime.c(9);
+  const {
+    field,
+    fieldState,
+    fieldProps,
+    onFieldChange
+  } = t0;
+  let t1;
+  if ($[0] !== field || $[1] !== fieldProps || $[2] !== fieldState) {
+    t1 = Object.assign(Object.assign({}, fieldProps), {
+      field,
+      fieldState
+    });
+    $[0] = field;
+    $[1] = fieldProps;
+    $[2] = fieldState;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const config = t1;
+  let t2;
+  if ($[4] !== config || $[5] !== fieldProps.errorNs || $[6] !== fieldProps.ns || $[7] !== onFieldChange) {
+    t2 = jsxRuntime.jsx(FormField, {
+      config,
+      ns: fieldProps.ns,
+      globalErrorNs: fieldProps.errorNs,
+      onFieldChange
+    });
+    $[4] = config;
+    $[5] = fieldProps.errorNs;
+    $[6] = fieldProps.ns;
+    $[7] = onFieldChange;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  return t2;
+};
+const DynamicFieldItem = ({
+  item,
+  form,
+  globalErrorNs,
+  formId
+}) => {
+  const {
+    get,
+    set
+  } = useFormValues({
+    formId
+  });
+  const fieldProps = React.useMemo(() => {
+    if (typeof item === 'function') {
+      return item({
+        get,
+        set
+      });
+    } else {
+      return item;
+    }
+  }, [get, set, item]);
+  const isHidden = React.useMemo(() => {
+    if (!fieldProps.hidden) {
+      return false;
+    } else if (typeof fieldProps.hidden === 'function') {
+      return fieldProps.hidden({
+        get,
+        set
+      });
+    } else {
+      return !!fieldProps.hidden;
+    }
+  }, [get, set, fieldProps]);
+  const rules = React.useMemo(() => {
+    if (!fieldProps.rules) {
+      return undefined;
+    } else if (typeof fieldProps.rules === 'function') {
+      return fieldProps.rules({
+        get,
+        set
+      });
+    } else {
+      return fieldProps.rules;
+    }
+  }, [get, set, fieldProps]);
+  const props = React.useMemo(() => {
+    var _a;
+    return Object.assign(Object.assign({}, fieldProps), {
+      errorNs: (_a = fieldProps.errorNs) !== null && _a !== void 0 ? _a : globalErrorNs
+    });
+  }, [fieldProps, globalErrorNs]);
+  if (isHidden) {
+    return jsxRuntime.jsx(jsxRuntime.Fragment, {});
+  }
+  return jsxRuntime.jsx(form.Field, {
+    name: props.name,
+    validators: rules,
+    // eslint-disable-next-line react/no-children-prop
+    children: field => jsxRuntime.jsx(RenderField, {
+      field: field,
+      fieldState: field.state,
+      fieldProps: props,
+      onFieldChange: props.onFieldChange
+    })
+  });
+};
+const SubmitItem = ({
+  item,
+  index,
+  handlersRef
+}) => {
+  const handleClick = React.useCallback(async () => {
+    const {
+      formControl,
+      createSubmitHandler,
+      onInvalidHandle
+    } = handlersRef.current;
+    // Partial or full validation logic
+    let isValid = true;
+    const keys = item.values;
+    if (keys && keys.length > 0) {
+      // Validate only specific fields
+      await Promise.all(keys.map(key => formControl.validateField(key, 'change')));
+      const hasError = keys.some(key_0 => {
+        // This is a simplified check. TanStack form errors might be structured differently.
+        // You might need deep checking if errors are nested objects.
+        // For now assume flat or use lodash get if possible, but state.errors is usually flat-ish map in newer versions or object.
+        // Checking standard TanStack: form.state.fieldMeta[key]?.errors
+        const meta = formControl.getFieldMeta(key_0);
+        return (meta === null || meta === void 0 ? void 0 : meta.errors) && meta.errors.length > 0;
+      });
+      isValid = !hasError;
+    } else {
+      // Validate all
+      await formControl.validateAllFields('submit');
+      isValid = formControl.state.isValid;
+    }
+    if (!isValid) {
+      onInvalidHandle(formControl.state.errors, item);
+      return;
+    }
+    const values = formControl.state.values;
+    // Call handlers
+    await createSubmitHandler(item)(values);
+  }, [item, handlersRef]);
+  const Component = React.useMemo(() => item.component, [item]);
+  if (item.hidden || !Component) return jsxRuntime.jsx(jsxRuntime.Fragment, {});
+  return jsxRuntime.jsx(Component, {
+    onClick: handleClick,
+    index: index,
+    type: item.type || 'button'
+  }, `submit-${index}`);
+};
+const useFormManager = ({
+  data,
+  onInvalid,
+  submit = [],
+  notification,
+  formOptions,
+  onValuesChange,
+  globalErrorNs,
+  id = 'form-manager'
+}) => {
+  const formControl = useJotaiForm(formOptions);
+  const formState = React.useMemo(() => formControl.state, [formControl.state]);
+  const errors = React.useMemo(() => formState.errors, [formState.errors]);
+  const values = React.useMemo(() => formState.values, [formState.values]);
+  const setFormState = useSetFormState(id);
+  const {
+    showNotification
+  } = useFormConfigValue();
+  const setValue = React.useCallback((field, updater) => formControl.setFieldValue(field, updater), [formControl]);
+  React.useEffect(() => {
+    setFormState({
+      setValue,
+      formValues: formState.values
+    });
+    const unsubscribe = formControl.store.subscribe(store => {
+      setFormState({
+        formValues: store.currentVal.values
+      });
+    });
+    return () => {
+      unsubscribe();
+    }; /**/
+  }, [formControl.store, setValue, formState.values, setFormState]);
+  const handleNotification = React.useCallback(props => {
+    if (props.message) {
+      showNotification === null || showNotification === void 0 ? void 0 : showNotification(props);
+    }
+  }, [showNotification]);
+  const filterFormData = React.useCallback((v, submitConfig) => {
+    const keys = submitConfig.values;
+    if (!keys || keys.length === 0) {
+      return v;
+    }
+    const out = {};
+    for (const key of keys) {
+      if (key in v) {
+        out[key] = v[key];
+      }
+    }
+    return out;
+  }, []);
+  const processSubmit = React.useCallback(async (d, submitConfig_0) => {
+    const filteredData = filterFormData(d, submitConfig_0);
+    if (submitConfig_0.onSuccess) {
+      return await submitConfig_0.onSuccess(filteredData);
+    }
+    throw new Error('No submit handler provided');
+  }, [filterFormData]);
+  const handleError = React.useCallback((error, submitConfig_1) => {
+    if (submitConfig_1.onError) {
+      submitConfig_1.onError(error);
+    }
+    const notificationProps = typeof (notification === null || notification === void 0 ? void 0 : notification.error) === 'function' ? notification.error(error.message) : notification === null || notification === void 0 ? void 0 : notification.error;
+    if (notificationProps === null || notificationProps === void 0 ? void 0 : notificationProps.message) {
+      handleNotification(notificationProps);
+    }
+  }, [handleNotification, notification]);
+  const createSubmitHandler = React.useCallback(submitConfig_2 => async dataSubmit => {
+    try {
+      const res = await processSubmit(trimObject(dataSubmit), submitConfig_2);
+      const notificationProps_0 = typeof (notification === null || notification === void 0 ? void 0 : notification.success) === 'function' ? notification.success(res) : notification === null || notification === void 0 ? void 0 : notification.success;
+      if (notificationProps_0 === null || notificationProps_0 === void 0 ? void 0 : notificationProps_0.message) {
+        handleNotification(notificationProps_0);
+      }
+      return res;
+    } catch (error_0) {
+      handleError(error_0, submitConfig_2);
+      throw error_0;
+    }
+  }, [processSubmit, notification, handleNotification, handleError]);
+  const onInvalidHandle = React.useCallback((err, submitConfig_3) => {
+    onInvalid === null || onInvalid === void 0 ? void 0 : onInvalid(err);
+    handleError(new Error('invalidData'), submitConfig_3);
+  }, [handleError, onInvalid]);
+  const handlersRef = React.useRef({
+    formControl,
+    onInvalidHandle,
+    createSubmitHandler,
+    setValue: formControl.setFieldValue,
+    trigger: formControl.validateField,
+    onValuesChange
+  });
+  React.useEffect(() => {
+    handlersRef.current.onInvalidHandle = onInvalidHandle;
+    handlersRef.current.createSubmitHandler = createSubmitHandler;
+    handlersRef.current.setValue = formControl.setFieldValue;
+    handlersRef.current.trigger = formControl.validateField;
+    handlersRef.current.onValuesChange = onValuesChange;
+  }, [onInvalidHandle, createSubmitHandler, formControl, onValuesChange]);
+  const fields = React.useMemo(() => data.map((item, index) => {
+    var _a, _b;
+    const staticItem = typeof item === 'function' ? null : item;
+    return {
+      index: (_a = staticItem === null || staticItem === void 0 ? void 0 : staticItem.index) !== null && _a !== void 0 ? _a : index,
+      element: jsxRuntime.jsx(DynamicFieldItem, {
+        item: item,
+        form: formControl,
+        globalErrorNs: globalErrorNs,
+        formId: id
+      }, (_b = staticItem === null || staticItem === void 0 ? void 0 : staticItem.name) !== null && _b !== void 0 ? _b : index),
+      renderInFooter: !!(staticItem === null || staticItem === void 0 ? void 0 : staticItem.renderInFooter),
+      renderInHeader: !!(staticItem === null || staticItem === void 0 ? void 0 : staticItem.renderInHeader)
+    };
+  }), [data, formControl, globalErrorNs, id]);
+  const submits = React.useMemo(() => submit.map((submitConfig_4, index_0) => {
+    return {
+      index: submitConfig_4.index === undefined ? index_0 : submitConfig_4.index,
+      element: jsxRuntime.jsx(SubmitItem, {
+        item: submitConfig_4,
+        index: index_0,
+        handlersRef: handlersRef
+      }, `submit-${index_0}`),
+      renderInFooter: !!submitConfig_4.renderInFooter,
+      renderInHeader: !!submitConfig_4.renderInHeader,
+      isSubmit: true
+    };
+  }), [submit]);
+  const elements = React.useMemo(() => fields.concat(submits), [fields, submits]);
+  const formContents = React.useMemo(() => [...data, ...submit], [data, submit]);
+  React.useEffect(() => {
+    var _a_0, _b_0;
+    (_b_0 = (_a_0 = handlersRef.current).onValuesChange) === null || _b_0 === void 0 ? void 0 : _b_0.call(_a_0, values, handlersRef.current.setValue);
+  }, [values]);
+  return {
+    elements,
+    formContents,
+    errors,
+    formValues: values,
+    setValue
+  };
+};// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const FormManager = t0 => {
+  const $ = compilerRuntime.c(29);
+  const {
+    data,
+    defaultValues,
+    onInvalid,
+    submit: t1,
+    ns,
+    globalErrorNs,
+    notification,
+    formSettings,
+    viewSettings,
+    onValuesChange,
+    id: t2
+  } = t0;
+  let t3;
+  if ($[0] !== t1) {
+    t3 = t1 === undefined ? [] : t1;
+    $[0] = t1;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  const submit = t3;
+  const id = t2 === undefined ? "form-manager" : t2;
+  let t4;
+  if ($[2] !== defaultValues || $[3] !== formSettings || $[4] !== id) {
+    t4 = Object.assign(Object.assign({
+      defaultValues
+    }, formSettings), {
+      formId: id
+    });
+    $[2] = defaultValues;
+    $[3] = formSettings;
+    $[4] = id;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== data || $[7] !== globalErrorNs || $[8] !== id || $[9] !== notification || $[10] !== ns || $[11] !== onInvalid || $[12] !== onValuesChange || $[13] !== submit || $[14] !== t4) {
+    t5 = {
+      data,
+      globalErrorNs,
+      notification,
+      ns,
+      onInvalid,
+      submit,
+      onValuesChange,
+      id,
+      formOptions: t4
+    };
+    $[6] = data;
+    $[7] = globalErrorNs;
+    $[8] = id;
+    $[9] = notification;
+    $[10] = ns;
+    $[11] = onInvalid;
+    $[12] = onValuesChange;
+    $[13] = submit;
+    $[14] = t4;
+    $[15] = t5;
+  } else {
+    t5 = $[15];
+  }
+  const {
+    elements: t6
+  } = useFormManager(t5);
+  let t7;
+  if ($[16] !== t6) {
+    t7 = t6 === undefined ? [] : t6;
+    $[16] = t6;
+    $[17] = t7;
+  } else {
+    t7 = $[17];
+  }
+  const elements = t7;
+  let t8;
+  if ($[18] !== elements) {
+    t8 = elements.filter(_temp).sort(_temp2).map(_temp3);
+    $[18] = elements;
+    $[19] = t8;
+  } else {
+    t8 = $[19];
+  }
+  const render = t8;
+  let t9;
+  if ($[20] !== elements) {
+    t9 = elements.filter(_temp4).sort(_temp5).map(_temp6);
+    $[20] = elements;
+    $[21] = t9;
+  } else {
+    t9 = $[21];
+  }
+  const renderSubmit = t9;
+  const Container = (viewSettings === null || viewSettings === void 0 ? void 0 : viewSettings.container) || DefaultFormContainer;
+  const BodyContainer = (viewSettings === null || viewSettings === void 0 ? void 0 : viewSettings.bodyContainer) || exports.DefaultContainer;
+  const SubmitContainer = (viewSettings === null || viewSettings === void 0 ? void 0 : viewSettings.submitContainer) || exports.DefaultContainer;
+  let t10;
+  if ($[22] !== BodyContainer || $[23] !== Container || $[24] !== SubmitContainer || $[25] !== render || $[26] !== renderSubmit || $[27] !== viewSettings) {
+    t10 = jsxRuntime.jsxs(Container, Object.assign({}, (viewSettings === null || viewSettings === void 0 ? void 0 : viewSettings.containerProps) || {}, {
+      children: [jsxRuntime.jsx(BodyContainer, Object.assign({}, (viewSettings === null || viewSettings === void 0 ? void 0 : viewSettings.bodyContainerProps) || {}, {
+        children: render
+      })), jsxRuntime.jsx(SubmitContainer, Object.assign({}, (viewSettings === null || viewSettings === void 0 ? void 0 : viewSettings.submitContainerProps) || {}, {
+        children: renderSubmit
+      }))]
+    }));
+    $[22] = BodyContainer;
+    $[23] = Container;
+    $[24] = SubmitContainer;
+    $[25] = render;
+    $[26] = renderSubmit;
+    $[27] = viewSettings;
+    $[28] = t10;
+  } else {
+    t10 = $[28];
+  }
+  return t10;
+};
+function _temp(el) {
+  return !el.isSubmit;
+}
+function _temp2(a, b) {
+  return a.index - b.index;
+}
+function _temp3(el_0) {
+  return el_0.element;
+}
+function _temp4(el_1) {
+  return el_1.isSubmit;
+}
+function _temp5(a_0, b_0) {
+  return a_0.index - b_0.index;
+}
+function _temp6(el_2) {
+  return el_2.element;
+}exports.DEFAULT_FORM_ENTRY=DEFAULT_FORM_ENTRY;exports.DefaultFormContainer=DefaultFormContainer;exports.FormField=FormField;exports.FormManager=FormManager;exports.createFormSelector=createFormSelector;exports.createScopeFormsAtom=createScopeFormsAtom;exports.formAtom=formAtom;exports.formConfigAtom=formConfigAtom;exports.getFormCompositeKey=getFormCompositeKey;exports.setDefaultFormContainer=setDefaultFormContainer;exports.useFormConfigReset=useFormConfigReset;exports.useFormConfigState=useFormConfigState;exports.useFormConfigValue=useFormConfigValue;exports.useFormManager=useFormManager;exports.useFormState=useFormState;exports.useFormValue=useFormValue;exports.useFormValues=useFormValues;exports.useJotaiForm=useJotaiForm;exports.useSetFormState=useSetFormState;//# sourceMappingURL=index.js.map