@saas-ui/react 2.11.2 → 3.0.0-alpha.1

package/dist/components/loading-overlay/index.cjs

@@ -0,0 +1,1921 @@
+'use client'
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/loading-overlay/index.ts
+var loading_overlay_exports = {};
+__export(loading_overlay_exports, {
+  LoadingOverlay: () => namespace_exports
+});
+module.exports = __toCommonJS(loading_overlay_exports);
+
+// src/components/loading-overlay/namespace.ts
+var namespace_exports = {};
+__export(namespace_exports, {
+  Root: () => LoadingOverlayRoot,
+  Spinner: () => LoadingOverlaySpinner,
+  Text: () => LoadingOverlayText
+});
+
+// ../../node_modules/@ark-ui/react/dist/components/presence/presence.js
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var import_react6 = require("react");
+
+// ../../node_modules/@ark-ui/react/dist/utils/compose-refs.js
+function setRef(ref2, value) {
+  if (typeof ref2 === "function") {
+    ref2(value);
+  } else if (ref2 !== null && ref2 !== void 0) {
+    ref2.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref2 of refs) {
+      setRef(ref2, node);
+    }
+  };
+}
+
+// ../../node_modules/proxy-compare/dist/index.js
+var TRACK_MEMO_SYMBOL = Symbol();
+var GET_ORIGINAL_SYMBOL = Symbol();
+var AFFECTED_PROPERTY = "a";
+var IS_TARGET_COPIED_PROPERTY = "f";
+var PROXY_PROPERTY = "p";
+var PROXY_CACHE_PROPERTY = "c";
+var TARGET_CACHE_PROPERTY = "t";
+var NEXT_OBJECT_PROPERTY = "n";
+var CHANGED_PROPERTY = "g";
+var HAS_KEY_PROPERTY = "h";
+var ALL_OWN_KEYS_PROPERTY = "w";
+var HAS_OWN_KEY_PROPERTY = "o";
+var KEYS_PROPERTY = "k";
+var newProxy = (target, handler) => new Proxy(target, handler);
+var getProto = Object.getPrototypeOf;
+var objectsToTrack = /* @__PURE__ */ new WeakMap();
+var isObjectToTrack = (obj) => obj && (objectsToTrack.has(obj) ? objectsToTrack.get(obj) : getProto(obj) === Object.prototype || getProto(obj) === Array.prototype);
+var isObject = (x) => typeof x === "object" && x !== null;
+var needsToCopyTargetObject = (obj) => Object.values(Object.getOwnPropertyDescriptors(obj)).some((descriptor) => !descriptor.configurable && !descriptor.writable);
+var copyTargetObject = (obj) => {
+  if (Array.isArray(obj)) {
+    return Array.from(obj);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  Object.values(descriptors).forEach((desc) => {
+    desc.configurable = true;
+  });
+  return Object.create(getProto(obj), descriptors);
+};
+var createProxyHandler = (origObj, isTargetCopied) => {
+  const state = {
+    [IS_TARGET_COPIED_PROPERTY]: isTargetCopied
+  };
+  let trackObject = false;
+  const recordUsage = (type, key) => {
+    if (!trackObject) {
+      let used = state[AFFECTED_PROPERTY].get(origObj);
+      if (!used) {
+        used = {};
+        state[AFFECTED_PROPERTY].set(origObj, used);
+      }
+      if (type === ALL_OWN_KEYS_PROPERTY) {
+        used[ALL_OWN_KEYS_PROPERTY] = true;
+      } else {
+        let set2 = used[type];
+        if (!set2) {
+          set2 = /* @__PURE__ */ new Set();
+          used[type] = set2;
+        }
+        set2.add(key);
+      }
+    }
+  };
+  const recordObjectAsUsed = () => {
+    trackObject = true;
+    state[AFFECTED_PROPERTY].delete(origObj);
+  };
+  const handler = {
+    get(target, key) {
+      if (key === GET_ORIGINAL_SYMBOL) {
+        return origObj;
+      }
+      recordUsage(KEYS_PROPERTY, key);
+      return createProxy(Reflect.get(target, key), state[AFFECTED_PROPERTY], state[PROXY_CACHE_PROPERTY], state[TARGET_CACHE_PROPERTY]);
+    },
+    has(target, key) {
+      if (key === TRACK_MEMO_SYMBOL) {
+        recordObjectAsUsed();
+        return true;
+      }
+      recordUsage(HAS_KEY_PROPERTY, key);
+      return Reflect.has(target, key);
+    },
+    getOwnPropertyDescriptor(target, key) {
+      recordUsage(HAS_OWN_KEY_PROPERTY, key);
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    },
+    ownKeys(target) {
+      recordUsage(ALL_OWN_KEYS_PROPERTY);
+      return Reflect.ownKeys(target);
+    }
+  };
+  if (isTargetCopied) {
+    handler.set = handler.deleteProperty = () => false;
+  }
+  return [handler, state];
+};
+var getOriginalObject = (obj) => (
+  // unwrap proxy
+  obj[GET_ORIGINAL_SYMBOL] || // otherwise
+  obj
+);
+var createProxy = (obj, affected, proxyCache, targetCache2) => {
+  if (!isObjectToTrack(obj))
+    return obj;
+  let targetAndCopied = targetCache2 && targetCache2.get(obj);
+  if (!targetAndCopied) {
+    const target2 = getOriginalObject(obj);
+    if (needsToCopyTargetObject(target2)) {
+      targetAndCopied = [target2, copyTargetObject(target2)];
+    } else {
+      targetAndCopied = [target2];
+    }
+    targetCache2 === null || targetCache2 === void 0 ? void 0 : targetCache2.set(obj, targetAndCopied);
+  }
+  const [target, copiedTarget] = targetAndCopied;
+  let handlerAndState = proxyCache && proxyCache.get(target);
+  if (!handlerAndState || handlerAndState[1][IS_TARGET_COPIED_PROPERTY] !== !!copiedTarget) {
+    handlerAndState = createProxyHandler(target, !!copiedTarget);
+    handlerAndState[1][PROXY_PROPERTY] = newProxy(copiedTarget || target, handlerAndState[0]);
+    if (proxyCache) {
+      proxyCache.set(target, handlerAndState);
+    }
+  }
+  handlerAndState[1][AFFECTED_PROPERTY] = affected;
+  handlerAndState[1][PROXY_CACHE_PROPERTY] = proxyCache;
+  handlerAndState[1][TARGET_CACHE_PROPERTY] = targetCache2;
+  return handlerAndState[1][PROXY_PROPERTY];
+};
+var isAllOwnKeysChanged = (prevObj, nextObj) => {
+  const prevKeys = Reflect.ownKeys(prevObj);
+  const nextKeys = Reflect.ownKeys(nextObj);
+  return prevKeys.length !== nextKeys.length || prevKeys.some((k, i) => k !== nextKeys[i]);
+};
+var isChanged = (prevObj, nextObj, affected, cache, isEqual2 = Object.is) => {
+  if (isEqual2(prevObj, nextObj)) {
+    return false;
+  }
+  if (!isObject(prevObj) || !isObject(nextObj))
+    return true;
+  const used = affected.get(getOriginalObject(prevObj));
+  if (!used)
+    return true;
+  if (cache) {
+    const hit = cache.get(prevObj);
+    if (hit && hit[NEXT_OBJECT_PROPERTY] === nextObj) {
+      return hit[CHANGED_PROPERTY];
+    }
+    cache.set(prevObj, {
+      [NEXT_OBJECT_PROPERTY]: nextObj,
+      [CHANGED_PROPERTY]: false
+    });
+  }
+  let changed = null;
+  try {
+    for (const key of used[HAS_KEY_PROPERTY] || []) {
+      changed = Reflect.has(prevObj, key) !== Reflect.has(nextObj, key);
+      if (changed)
+        return changed;
+    }
+    if (used[ALL_OWN_KEYS_PROPERTY] === true) {
+      changed = isAllOwnKeysChanged(prevObj, nextObj);
+      if (changed)
+        return changed;
+    } else {
+      for (const key of used[HAS_OWN_KEY_PROPERTY] || []) {
+        const hasPrev = !!Reflect.getOwnPropertyDescriptor(prevObj, key);
+        const hasNext = !!Reflect.getOwnPropertyDescriptor(nextObj, key);
+        changed = hasPrev !== hasNext;
+        if (changed)
+          return changed;
+      }
+    }
+    for (const key of used[KEYS_PROPERTY] || []) {
+      changed = isChanged(prevObj[key], nextObj[key], affected, cache, isEqual2);
+      if (changed)
+        return changed;
+    }
+    if (changed === null)
+      changed = true;
+    return changed;
+  } finally {
+    if (cache) {
+      cache.set(prevObj, {
+        [NEXT_OBJECT_PROPERTY]: nextObj,
+        [CHANGED_PROPERTY]: changed
+      });
+    }
+  }
+};
+var getUntracked = (obj) => {
+  if (isObjectToTrack(obj)) {
+    return obj[GET_ORIGINAL_SYMBOL] || null;
+  }
+  return null;
+};
+var markToTrack = (obj, mark = true) => {
+  objectsToTrack.set(obj, mark);
+};
+
+// ../../node_modules/@zag-js/store/dist/index.mjs
+function getGlobal() {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof self !== "undefined") return self;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+}
+function makeGlobal(key, value) {
+  const g = getGlobal();
+  if (!g) return value();
+  g[key] || (g[key] = value());
+  return g[key];
+}
+var isDev = () => process.env.NODE_ENV !== "production";
+var isObject2 = (x) => typeof x === "object" && x !== null;
+var proxyStateMap = makeGlobal("__zag__proxyStateMap", () => /* @__PURE__ */ new WeakMap());
+var refSet = makeGlobal("__zag__refSet", () => /* @__PURE__ */ new WeakSet());
+var isReactElement = (x) => typeof x === "object" && x !== null && "$$typeof" in x;
+var isVueElement = (x) => typeof x === "object" && x !== null && "__v_isVNode" in x;
+var isDOMElement = (x) => typeof x === "object" && x !== null && "nodeType" in x && typeof x.nodeName === "string";
+var isElement = (x) => isReactElement(x) || isVueElement(x) || isDOMElement(x);
+var buildProxyFunction = (objectIs = Object.is, newProxy2 = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject2(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !isElement(x) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer), defaultHandlePromise = (promise) => {
+  switch (promise.status) {
+    case "fulfilled":
+      return promise.value;
+    case "rejected":
+      throw promise.reason;
+    default:
+      throw promise;
+  }
+}, snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version, handlePromise = defaultHandlePromise) => {
+  const cache = snapCache.get(target);
+  if ((cache == null ? void 0 : cache[0]) === version) {
+    return cache[1];
+  }
+  const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+  markToTrack(snap, true);
+  snapCache.set(target, [version, snap]);
+  Reflect.ownKeys(target).forEach((key) => {
+    const value = Reflect.get(target, key);
+    if (refSet.has(value)) {
+      markToTrack(value, false);
+      snap[key] = value;
+    } else if (value instanceof Promise) {
+      Object.defineProperty(snap, key, {
+        get() {
+          return handlePromise(value);
+        }
+      });
+    } else if (proxyStateMap.has(value)) {
+      snap[key] = snapshot(value, handlePromise);
+    } else {
+      snap[key] = value;
+    }
+  });
+  return Object.freeze(snap);
+}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction2 = (initialObject) => {
+  if (!isObject2(initialObject)) {
+    throw new Error("object required");
+  }
+  const found = proxyCache.get(initialObject);
+  if (found) {
+    return found;
+  }
+  let version = versionHolder[0];
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
+    if (version !== nextVersion) {
+      version = nextVersion;
+      listeners.forEach((listener) => listener(op, nextVersion));
+    }
+  };
+  let checkVersion = versionHolder[1];
+  const ensureVersion = (nextCheckVersion = ++versionHolder[1]) => {
+    if (checkVersion !== nextCheckVersion && !listeners.size) {
+      checkVersion = nextCheckVersion;
+      propProxyStates.forEach(([propProxyState]) => {
+        const propVersion = propProxyState[1](nextCheckVersion);
+        if (propVersion > version) {
+          version = propVersion;
+        }
+      });
+    }
+    return version;
+  };
+  const createPropListener = (prop) => (op, nextVersion) => {
+    const newOp = [...op];
+    newOp[1] = [prop, ...newOp[1]];
+    notifyUpdate(newOp, nextVersion);
+  };
+  const propProxyStates = /* @__PURE__ */ new Map();
+  const addPropListener = (prop, propProxyState) => {
+    if (isDev() && propProxyStates.has(prop)) {
+      throw new Error("prop listener already exists");
+    }
+    if (listeners.size) {
+      const remove = propProxyState[3](createPropListener(prop));
+      propProxyStates.set(prop, [propProxyState, remove]);
+    } else {
+      propProxyStates.set(prop, [propProxyState]);
+    }
+  };
+  const removePropListener = (prop) => {
+    var _a;
+    const entry = propProxyStates.get(prop);
+    if (entry) {
+      propProxyStates.delete(prop);
+      (_a = entry[1]) == null ? void 0 : _a.call(entry);
+    }
+  };
+  const addListener = (listener) => {
+    listeners.add(listener);
+    if (listeners.size === 1) {
+      propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
+        if (isDev() && prevRemove) {
+          throw new Error("remove already exists");
+        }
+        const remove = propProxyState[3](createPropListener(prop));
+        propProxyStates.set(prop, [propProxyState, remove]);
+      });
+    }
+    const removeListener = () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        propProxyStates.forEach(([propProxyState, remove], prop) => {
+          if (remove) {
+            remove();
+            propProxyStates.set(prop, [propProxyState]);
+          }
+        });
+      }
+    };
+    return removeListener;
+  };
+  const baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
+  const handler = {
+    deleteProperty(target, prop) {
+      const prevValue = Reflect.get(target, prop);
+      removePropListener(prop);
+      const deleted = Reflect.deleteProperty(target, prop);
+      if (deleted) {
+        notifyUpdate(["delete", [prop], prevValue]);
+      }
+      return deleted;
+    },
+    set(target, prop, value, receiver) {
+      var _a;
+      const hasPrevValue = Reflect.has(target, prop);
+      const prevValue = Reflect.get(target, prop, receiver);
+      if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
+        return true;
+      }
+      removePropListener(prop);
+      if (isObject2(value)) {
+        value = getUntracked(value) || value;
+      }
+      let nextValue = value;
+      if ((_a = Object.getOwnPropertyDescriptor(target, prop)) == null ? void 0 : _a.set) ;
+      else if (value instanceof Promise) {
+        value.then((v) => {
+          Object.assign(value, { status: "fulfilled", value: v });
+          notifyUpdate(["resolve", [prop], v]);
+        }).catch((e) => {
+          Object.assign(value, { status: "rejected", reason: e });
+          notifyUpdate(["reject", [prop], e]);
+        });
+      } else {
+        if (!proxyStateMap.has(value) && canProxy(value)) {
+          nextValue = proxy(value);
+        }
+        const childProxyState = !refSet.has(nextValue) && proxyStateMap.get(nextValue);
+        if (childProxyState) {
+          addPropListener(prop, childProxyState);
+        }
+      }
+      Reflect.set(target, prop, nextValue, receiver);
+      notifyUpdate(["set", [prop], value, prevValue]);
+      return true;
+    }
+  };
+  const proxyObject = newProxy2(baseObject, handler);
+  proxyCache.set(initialObject, proxyObject);
+  const proxyState = [baseObject, ensureVersion, createSnapshot, addListener];
+  proxyStateMap.set(proxyObject, proxyState);
+  Reflect.ownKeys(initialObject).forEach((key) => {
+    const desc = Object.getOwnPropertyDescriptor(initialObject, key);
+    if (desc.get || desc.set) {
+      Object.defineProperty(baseObject, key, desc);
+    } else {
+      proxyObject[key] = initialObject[key];
+    }
+  });
+  return proxyObject;
+}) => [
+  // public functions
+  proxyFunction2,
+  // shared state
+  proxyStateMap,
+  refSet,
+  // internal things
+  objectIs,
+  newProxy2,
+  canProxy,
+  defaultHandlePromise,
+  snapCache,
+  createSnapshot,
+  proxyCache,
+  versionHolder
+];
+var [proxyFunction] = buildProxyFunction();
+function proxy(initialObject = {}) {
+  return proxyFunction(initialObject);
+}
+function subscribe(proxyObject, callback, notifyInSync) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if (isDev() && !proxyState) {
+    console.warn("Please use proxy object");
+  }
+  let promise;
+  const ops = [];
+  const addListener = proxyState[3];
+  let isListenerActive = false;
+  const listener = (op) => {
+    ops.push(op);
+    if (notifyInSync) {
+      callback(ops.splice(0));
+      return;
+    }
+    if (!promise) {
+      promise = Promise.resolve().then(() => {
+        promise = void 0;
+        if (isListenerActive) {
+          callback(ops.splice(0));
+        }
+      });
+    }
+  };
+  const removeListener = addListener(listener);
+  isListenerActive = true;
+  return () => {
+    isListenerActive = false;
+    removeListener();
+  };
+}
+function snapshot(proxyObject, handlePromise) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if (isDev() && !proxyState) {
+    console.warn("Please use proxy object");
+  }
+  const [target, ensureVersion, createSnapshot] = proxyState;
+  return createSnapshot(target, ensureVersion(), handlePromise);
+}
+function ref(obj) {
+  refSet.add(obj);
+  return obj;
+}
+function proxyWithComputed(initialObject, computedFns) {
+  const keys = Object.keys(computedFns);
+  keys.forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(initialObject, key)) {
+      throw new Error("object property already defined");
+    }
+    const computedFn = computedFns[key];
+    const { get, set: set2 } = typeof computedFn === "function" ? { get: computedFn } : computedFn;
+    const desc = {};
+    desc.get = () => get(snapshot(proxyObject));
+    if (set2) {
+      desc.set = (newValue) => set2(proxyObject, newValue);
+    }
+    Object.defineProperty(initialObject, key, desc);
+  });
+  const proxyObject = proxy(initialObject);
+  return proxyObject;
+}
+
+// ../../node_modules/@zag-js/utils/dist/index.mjs
+function clear(v) {
+  while (v.length > 0) v.pop();
+  return v;
+}
+var runIfFn = (v, ...a) => {
+  const res = typeof v === "function" ? v(...a) : v;
+  return res != null ? res : void 0;
+};
+var cast = (v) => v;
+var noop = () => {
+};
+var callAll = (...fns) => (...a) => {
+  fns.forEach(function(fn) {
+    fn == null ? void 0 : fn(...a);
+  });
+};
+var uuid = /* @__PURE__ */ (() => {
+  let id = 0;
+  return () => {
+    id++;
+    return id.toString(36);
+  };
+})();
+var isDev2 = () => process.env.NODE_ENV !== "production";
+var isArray = (v) => Array.isArray(v);
+var isObjectLike = (v) => v != null && typeof v === "object";
+var isObject3 = (v) => isObjectLike(v) && !isArray(v);
+var isNumber = (v) => typeof v === "number" && !Number.isNaN(v);
+var isString = (v) => typeof v === "string";
+var isFunction = (v) => typeof v === "function";
+var hasProp = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+var baseGetTag = (v) => Object.prototype.toString.call(v);
+var fnToString = Function.prototype.toString;
+var objectCtorString = fnToString.call(Object);
+var isPlainObject = (v) => {
+  if (!isObjectLike(v) || baseGetTag(v) != "[object Object]") return false;
+  const proto = Object.getPrototypeOf(v);
+  if (proto === null) return true;
+  const Ctor = hasProp(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && fnToString.call(Ctor) == objectCtorString;
+};
+function compact(obj) {
+  if (!isPlainObject2(obj) || obj === void 0) {
+    return obj;
+  }
+  const keys = Reflect.ownKeys(obj).filter((key) => typeof key === "string");
+  const filtered = {};
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      filtered[key] = compact(value);
+    }
+  }
+  return filtered;
+}
+var isPlainObject2 = (value) => {
+  return value && typeof value === "object" && value.constructor === Object;
+};
+function warn(...a) {
+  const m = a.length === 1 ? a[0] : a[1];
+  const c = a.length === 2 ? a[0] : true;
+  if (c && process.env.NODE_ENV !== "production") {
+    console.warn(m);
+  }
+}
+function invariant(...a) {
+  const m = a.length === 1 ? a[0] : a[1];
+  const c = a.length === 2 ? a[0] : true;
+  if (c && process.env.NODE_ENV !== "production") {
+    throw new Error(m);
+  }
+}
+
+// ../../node_modules/klona/full/index.mjs
+function set(obj, key, val) {
+  if (typeof val.value === "object") val.value = klona(val.value);
+  if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") {
+    Object.defineProperty(obj, key, val);
+  } else obj[key] = val.value;
+}
+function klona(x) {
+  if (typeof x !== "object") return x;
+  var i = 0, k, list, tmp, str = Object.prototype.toString.call(x);
+  if (str === "[object Object]") {
+    tmp = Object.create(x.__proto__ || null);
+  } else if (str === "[object Array]") {
+    tmp = Array(x.length);
+  } else if (str === "[object Set]") {
+    tmp = /* @__PURE__ */ new Set();
+    x.forEach(function(val) {
+      tmp.add(klona(val));
+    });
+  } else if (str === "[object Map]") {
+    tmp = /* @__PURE__ */ new Map();
+    x.forEach(function(val, key) {
+      tmp.set(klona(key), klona(val));
+    });
+  } else if (str === "[object Date]") {
+    tmp = /* @__PURE__ */ new Date(+x);
+  } else if (str === "[object RegExp]") {
+    tmp = new RegExp(x.source, x.flags);
+  } else if (str === "[object DataView]") {
+    tmp = new x.constructor(klona(x.buffer));
+  } else if (str === "[object ArrayBuffer]") {
+    tmp = x.slice(0);
+  } else if (str.slice(-6) === "Array]") {
+    tmp = new x.constructor(x);
+  }
+  if (tmp) {
+    for (list = Object.getOwnPropertySymbols(x); i < list.length; i++) {
+      set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
+    }
+    for (i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++) {
+      if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k]) continue;
+      set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
+    }
+  }
+  return tmp || x;
+}
+
+// ../../node_modules/@zag-js/core/dist/index.mjs
+var __defProp2 = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function deepMerge(source, ...objects) {
+  for (const obj of objects) {
+    const target = compact(obj);
+    for (const key in target) {
+      if (isPlainObject(obj[key])) {
+        if (!source[key]) {
+          source[key] = {};
+        }
+        deepMerge(source[key], obj[key]);
+      } else {
+        source[key] = obj[key];
+      }
+    }
+  }
+  return source;
+}
+function structuredClone(v) {
+  return klona(v);
+}
+function toEvent(event) {
+  const obj = isString(event) ? { type: event } : event;
+  return obj;
+}
+function toArray(value) {
+  if (!value) return [];
+  return isArray(value) ? value.slice() : [value];
+}
+function isGuardHelper(value) {
+  return isObject3(value) && value.predicate != null;
+}
+var Truthy = () => true;
+function determineGuardFn(guard, guardMap) {
+  guard = guard != null ? guard : Truthy;
+  return (context, event, meta) => {
+    if (isString(guard)) {
+      const value = guardMap[guard];
+      return isFunction(value) ? value(context, event, meta) : value;
+    }
+    if (isGuardHelper(guard)) {
+      return guard.predicate(guardMap)(context, event, meta);
+    }
+    return guard == null ? void 0 : guard(context, event, meta);
+  };
+}
+function determineActionsFn(values, guardMap) {
+  return (context, event, meta) => {
+    if (isGuardHelper(values)) {
+      return values.predicate(guardMap)(context, event, meta);
+    }
+    return values;
+  };
+}
+function createProxy2(config) {
+  var _a, _b, _c, _d, _e;
+  const computedContext = (_a = config.computed) != null ? _a : cast({});
+  const initialContext = (_b = config.context) != null ? _b : cast({});
+  const initialTags = config.initial ? (_d = (_c = config.states) == null ? void 0 : _c[config.initial]) == null ? void 0 : _d.tags : [];
+  const state = proxy({
+    value: (_e = config.initial) != null ? _e : "",
+    previousValue: "",
+    event: cast({}),
+    previousEvent: cast({}),
+    context: proxyWithComputed(initialContext, computedContext),
+    done: false,
+    tags: initialTags != null ? initialTags : [],
+    hasTag(tag) {
+      return this.tags.includes(tag);
+    },
+    matches(...value) {
+      return value.includes(this.value);
+    },
+    can(event) {
+      return cast(this).nextEvents.includes(event);
+    },
+    get nextEvents() {
+      var _a2, _b2, _c2, _d2;
+      const stateEvents = (_c2 = (_b2 = (_a2 = config.states) == null ? void 0 : _a2[this.value]) == null ? void 0 : _b2["on"]) != null ? _c2 : {};
+      const globalEvents = (_d2 = config == null ? void 0 : config.on) != null ? _d2 : {};
+      return Object.keys({ ...stateEvents, ...globalEvents });
+    },
+    get changed() {
+      if (this.event.value === "machine.init" || !this.previousValue) return false;
+      return this.value !== this.previousValue;
+    }
+  });
+  return cast(state);
+}
+function determineDelayFn(delay, delaysMap) {
+  return (context, event) => {
+    if (isNumber(delay)) return delay;
+    if (isFunction(delay)) {
+      return delay(context, event);
+    }
+    if (isString(delay)) {
+      const value = Number.parseFloat(delay);
+      if (!Number.isNaN(value)) {
+        return value;
+      }
+      if (delaysMap) {
+        const valueOrFn = delaysMap == null ? void 0 : delaysMap[delay];
+        invariant(
+          valueOrFn == null,
+          `[@zag-js/core > determine-delay] Cannot determine delay for \`${delay}\`. It doesn't exist in \`options.delays\``
+        );
+        return isFunction(valueOrFn) ? valueOrFn(context, event) : valueOrFn;
+      }
+    }
+  };
+}
+function toTarget(target) {
+  return isString(target) ? { target } : target;
+}
+function determineTransitionFn(transitions, guardMap) {
+  return (context, event, meta) => {
+    return toArray(transitions).map(toTarget).find((transition) => {
+      var _a;
+      const determineGuard = determineGuardFn(transition.guard, guardMap);
+      const guard = determineGuard(context, event, meta);
+      return (_a = guard != null ? guard : transition.target) != null ? _a : transition.actions;
+    });
+  };
+}
+var Machine = class {
+  // Let's get started!
+  constructor(config, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    __publicField(
+      this,
+      "status",
+      "Not Started"
+      /* NotStarted */
+    );
+    __publicField(this, "state");
+    __publicField(this, "initialState");
+    __publicField(this, "initialContext");
+    __publicField(this, "id");
+    __publicField(
+      this,
+      "type",
+      "machine"
+      /* Machine */
+    );
+    __publicField(this, "activityEvents", /* @__PURE__ */ new Map());
+    __publicField(this, "delayedEvents", /* @__PURE__ */ new Map());
+    __publicField(this, "stateListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "doneListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "contextWatchers", /* @__PURE__ */ new Set());
+    __publicField(this, "removeStateListener", noop);
+    __publicField(this, "parent");
+    __publicField(this, "children", /* @__PURE__ */ new Map());
+    __publicField(this, "guardMap");
+    __publicField(this, "actionMap");
+    __publicField(this, "delayMap");
+    __publicField(this, "activityMap");
+    __publicField(this, "sync");
+    __publicField(this, "options");
+    __publicField(this, "config");
+    __publicField(this, "_created", () => {
+      var _a2;
+      const event = toEvent(
+        "machine.created"
+        /* Created */
+      );
+      this.executeActions((_a2 = this.config) == null ? void 0 : _a2.created, event);
+    });
+    __publicField(this, "start", (init) => {
+      this.state.value = "";
+      this.state.tags = [];
+      if (this.status === "Running") {
+        return this;
+      }
+      this.status = "Running";
+      this.removeStateListener = subscribe(
+        this.state,
+        () => {
+          this.stateListeners.forEach((listener) => {
+            listener(this.stateSnapshot);
+          });
+        },
+        this.sync
+      );
+      this.setupContextWatchers();
+      this.executeActivities(
+        toEvent(
+          "machine.start"
+          /* Start */
+        ),
+        toArray(this.config.activities),
+        "machine.start"
+        /* Start */
+      );
+      this.executeActions(this.config.entry, toEvent(
+        "machine.start"
+        /* Start */
+      ));
+      const event = toEvent(
+        "machine.init"
+        /* Init */
+      );
+      const target = isObject3(init) ? init.value : init;
+      const context = isObject3(init) ? init.context : void 0;
+      if (context) {
+        this.setContext(context);
+      }
+      const transition = {
+        target: target != null ? target : this.config.initial
+      };
+      const next = this.getNextStateInfo(transition, event);
+      this.initialState = next;
+      this.performStateChangeEffects(this.state.value, next, event);
+      return this;
+    });
+    __publicField(this, "setupContextWatchers", () => {
+      const { watch } = this.config;
+      if (!watch) return;
+      let prev = snapshot(this.state.context);
+      const cleanup = subscribe(this.state.context, () => {
+        var _a2, _b2;
+        const next = snapshot(this.state.context);
+        for (const [key, fn] of Object.entries(watch)) {
+          const isEqual2 = (_b2 = (_a2 = this.options.compareFns) == null ? void 0 : _a2[key]) != null ? _b2 : Object.is;
+          if (isEqual2(prev[key], next[key])) continue;
+          this.executeActions(fn, this.state.event);
+        }
+        prev = next;
+      });
+      this.contextWatchers.add(cleanup);
+    });
+    __publicField(this, "stop", () => {
+      if (this.status === "Stopped") return;
+      this.performExitEffects(this.state.value, toEvent(
+        "machine.stop"
+        /* Stop */
+      ));
+      this.executeActions(this.config.exit, toEvent(
+        "machine.stop"
+        /* Stop */
+      ));
+      this.setState("");
+      this.setEvent(
+        "machine.stop"
+        /* Stop */
+      );
+      this.stopStateListeners();
+      this.stopChildren();
+      this.stopActivities();
+      this.stopDelayedEvents();
+      this.stopContextWatchers();
+      this.status = "Stopped";
+      return this;
+    });
+    __publicField(this, "stopStateListeners", () => {
+      this.removeStateListener();
+      this.stateListeners.clear();
+    });
+    __publicField(this, "stopContextWatchers", () => {
+      this.contextWatchers.forEach((fn) => fn());
+      this.contextWatchers.clear();
+    });
+    __publicField(this, "stopDelayedEvents", () => {
+      this.delayedEvents.forEach((state) => {
+        state.forEach((stop) => stop());
+      });
+      this.delayedEvents.clear();
+    });
+    __publicField(this, "stopActivities", (state) => {
+      var _a2, _b2;
+      if (state) {
+        (_a2 = this.activityEvents.get(state)) == null ? void 0 : _a2.forEach((stop) => stop());
+        (_b2 = this.activityEvents.get(state)) == null ? void 0 : _b2.clear();
+        this.activityEvents.delete(state);
+      } else {
+        this.activityEvents.forEach((state2) => {
+          state2.forEach((stop) => stop());
+          state2.clear();
+        });
+        this.activityEvents.clear();
+      }
+    });
+    __publicField(this, "sendChild", (evt, to) => {
+      const event = toEvent(evt);
+      const id = runIfFn(to, this.contextSnapshot);
+      const child = this.children.get(id);
+      if (!child) {
+        invariant(`[@zag-js/core] Cannot send '${event.type}' event to unknown child`);
+      }
+      child.send(event);
+    });
+    __publicField(this, "stopChild", (id) => {
+      if (!this.children.has(id)) {
+        invariant(`[@zag-js/core > stop-child] Cannot stop unknown child ${id}`);
+      }
+      this.children.get(id).stop();
+      this.children.delete(id);
+    });
+    __publicField(this, "removeChild", (id) => {
+      this.children.delete(id);
+    });
+    __publicField(this, "stopChildren", () => {
+      this.children.forEach((child) => child.stop());
+      this.children.clear();
+    });
+    __publicField(this, "setParent", (parent) => {
+      this.parent = parent;
+    });
+    __publicField(this, "spawn", (src, id) => {
+      const actor = runIfFn(src);
+      if (id) actor.id = id;
+      actor.type = "machine.actor";
+      actor.setParent(this);
+      this.children.set(actor.id, cast(actor));
+      actor.onDone(() => {
+        this.removeChild(actor.id);
+      }).start();
+      return cast(ref(actor));
+    });
+    __publicField(this, "stopActivity", (key) => {
+      var _a2;
+      if (!this.state.value) return;
+      const cleanups = this.activityEvents.get(this.state.value);
+      (_a2 = cleanups == null ? void 0 : cleanups.get(key)) == null ? void 0 : _a2();
+      cleanups == null ? void 0 : cleanups.delete(key);
+    });
+    __publicField(this, "addActivityCleanup", (state, key, cleanup) => {
+      var _a2;
+      if (!state) return;
+      if (!this.activityEvents.has(state)) {
+        this.activityEvents.set(state, /* @__PURE__ */ new Map([[key, cleanup]]));
+      } else {
+        (_a2 = this.activityEvents.get(state)) == null ? void 0 : _a2.set(key, cleanup);
+      }
+    });
+    __publicField(this, "setState", (target) => {
+      this.state.previousValue = this.state.value;
+      this.state.value = target;
+      const stateNode = this.getStateNode(target);
+      if (target == null) {
+        clear(this.state.tags);
+      } else {
+        this.state.tags = toArray(stateNode == null ? void 0 : stateNode.tags);
+      }
+    });
+    __publicField(this, "setContext", (context) => {
+      if (!context) return;
+      deepMerge(this.state.context, compact(context));
+    });
+    __publicField(this, "setOptions", (options2) => {
+      const opts = compact(options2);
+      this.actionMap = { ...this.actionMap, ...opts.actions };
+      this.delayMap = { ...this.delayMap, ...opts.delays };
+      this.activityMap = { ...this.activityMap, ...opts.activities };
+      this.guardMap = { ...this.guardMap, ...opts.guards };
+    });
+    __publicField(this, "getStateNode", (state) => {
+      var _a2;
+      if (!state) return;
+      return (_a2 = this.config.states) == null ? void 0 : _a2[state];
+    });
+    __publicField(this, "getNextStateInfo", (transitions, event) => {
+      var _a2;
+      const transition = this.determineTransition(transitions, event);
+      const isTargetless = !(transition == null ? void 0 : transition.target);
+      const target = (_a2 = transition == null ? void 0 : transition.target) != null ? _a2 : this.state.value;
+      const changed = this.state.value !== target;
+      const stateNode = this.getStateNode(target);
+      const reenter = !isTargetless && !changed && !(transition == null ? void 0 : transition.internal);
+      const info = {
+        reenter,
+        transition,
+        stateNode,
+        target,
+        changed
+      };
+      this.log("NextState:", `[${event.type}]`, this.state.value, "---->", info.target);
+      return info;
+    });
+    __publicField(this, "getAfterActions", (transition, delay) => {
+      let id;
+      const current = this.state.value;
+      return {
+        entry: () => {
+          id = globalThis.setTimeout(() => {
+            const next = this.getNextStateInfo(transition, this.state.event);
+            this.performStateChangeEffects(current, next, this.state.event);
+          }, delay);
+        },
+        exit: () => {
+          globalThis.clearTimeout(id);
+        }
+      };
+    });
+    __publicField(this, "getDelayedEventActions", (state) => {
+      const stateNode = this.getStateNode(state);
+      const event = this.state.event;
+      if (!stateNode || !stateNode.after) return;
+      const entries = [];
+      const exits = [];
+      if (isArray(stateNode.after)) {
+        const transition = this.determineTransition(stateNode.after, event);
+        if (!transition) return;
+        if (!hasProp(transition, "delay")) {
+          throw new Error(`[@zag-js/core > after] Delay is required for after transition: ${JSON.stringify(transition)}`);
+        }
+        const determineDelay = determineDelayFn(transition.delay, this.delayMap);
+        const __delay = determineDelay(this.contextSnapshot, event);
+        const actions = this.getAfterActions(transition, __delay);
+        entries.push(actions.entry);
+        exits.push(actions.exit);
+        return { entries, exits };
+      }
+      if (isObject3(stateNode.after)) {
+        for (const delay in stateNode.after) {
+          const transition = stateNode.after[delay];
+          const determineDelay = determineDelayFn(delay, this.delayMap);
+          const __delay = determineDelay(this.contextSnapshot, event);
+          const actions = this.getAfterActions(transition, __delay);
+          entries.push(actions.entry);
+          exits.push(actions.exit);
+        }
+      }
+      return { entries, exits };
+    });
+    __publicField(this, "executeActions", (actions, event) => {
+      var _a2;
+      const pickedActions = determineActionsFn(actions, this.guardMap)(this.contextSnapshot, event, this.guardMeta);
+      for (const action of toArray(pickedActions)) {
+        const fn = isString(action) ? (_a2 = this.actionMap) == null ? void 0 : _a2[action] : action;
+        warn(
+          isString(action) && !fn,
+          `[@zag-js/core > execute-actions] No implementation found for action: \`${action}\``
+        );
+        fn == null ? void 0 : fn(this.state.context, event, this.meta);
+      }
+    });
+    __publicField(this, "executeActivities", (event, activities, state) => {
+      var _a2;
+      for (const activity of activities) {
+        const fn = isString(activity) ? (_a2 = this.activityMap) == null ? void 0 : _a2[activity] : activity;
+        if (!fn) {
+          warn(`[@zag-js/core > execute-activity] No implementation found for activity: \`${activity}\``);
+          continue;
+        }
+        const cleanup = fn(this.state.context, event, this.meta);
+        if (cleanup) {
+          const key = isString(activity) ? activity : activity.name || uuid();
+          this.addActivityCleanup(state != null ? state : this.state.value, key, cleanup);
+        }
+      }
+    });
+    __publicField(this, "createEveryActivities", (every, callbackfn) => {
+      if (!every) return;
+      if (isArray(every)) {
+        const picked = toArray(every).find((transition) => {
+          const delayOrFn = transition.delay;
+          const determineDelay2 = determineDelayFn(delayOrFn, this.delayMap);
+          const delay2 = determineDelay2(this.contextSnapshot, this.state.event);
+          const determineGuard = determineGuardFn(transition.guard, this.guardMap);
+          const guard = determineGuard(this.contextSnapshot, this.state.event, this.guardMeta);
+          return guard != null ? guard : delay2 != null;
+        });
+        if (!picked) return;
+        const determineDelay = determineDelayFn(picked.delay, this.delayMap);
+        const delay = determineDelay(this.contextSnapshot, this.state.event);
+        const activity = () => {
+          const id = globalThis.setInterval(() => {
+            this.executeActions(picked.actions, this.state.event);
+          }, delay);
+          return () => {
+            globalThis.clearInterval(id);
+          };
+        };
+        callbackfn(activity);
+      } else {
+        for (const interval in every) {
+          const actions = every == null ? void 0 : every[interval];
+          const determineDelay = determineDelayFn(interval, this.delayMap);
+          const delay = determineDelay(this.contextSnapshot, this.state.event);
+          const activity = () => {
+            const id = globalThis.setInterval(() => {
+              this.executeActions(actions, this.state.event);
+            }, delay);
+            return () => {
+              globalThis.clearInterval(id);
+            };
+          };
+          callbackfn(activity);
+        }
+      }
+    });
+    __publicField(this, "setEvent", (event) => {
+      this.state.previousEvent = this.state.event;
+      this.state.event = ref(toEvent(event));
+    });
+    __publicField(this, "performExitEffects", (current, event) => {
+      const currentState = this.state.value;
+      if (currentState === "") return;
+      const stateNode = current ? this.getStateNode(current) : void 0;
+      this.stopActivities(currentState);
+      const _exit = determineActionsFn(stateNode == null ? void 0 : stateNode.exit, this.guardMap)(this.contextSnapshot, event, this.guardMeta);
+      const exitActions = toArray(_exit);
+      const afterExitActions = this.delayedEvents.get(currentState);
+      if (afterExitActions) {
+        exitActions.push(...afterExitActions);
+      }
+      this.executeActions(exitActions, event);
+      this.delayedEvents.delete(currentState);
+    });
+    __publicField(this, "performEntryEffects", (next, event) => {
+      const stateNode = this.getStateNode(next);
+      const activities = toArray(stateNode == null ? void 0 : stateNode.activities);
+      this.createEveryActivities(stateNode == null ? void 0 : stateNode.every, (activity) => {
+        activities.unshift(activity);
+      });
+      if (activities.length > 0) {
+        this.executeActivities(event, activities);
+      }
+      const pickedActions = determineActionsFn(stateNode == null ? void 0 : stateNode.entry, this.guardMap)(
+        this.contextSnapshot,
+        event,
+        this.guardMeta
+      );
+      const entryActions = toArray(pickedActions);
+      const afterActions = this.getDelayedEventActions(next);
+      if ((stateNode == null ? void 0 : stateNode.after) && afterActions) {
+        this.delayedEvents.set(next, afterActions == null ? void 0 : afterActions.exits);
+        entryActions.push(...afterActions.entries);
+      }
+      this.executeActions(entryActions, event);
+      if ((stateNode == null ? void 0 : stateNode.type) === "final") {
+        this.state.done = true;
+        this.doneListeners.forEach((listener) => {
+          listener(this.stateSnapshot);
+        });
+        this.stop();
+      }
+    });
+    __publicField(this, "performTransitionEffects", (transitions, event) => {
+      const transition = this.determineTransition(transitions, event);
+      this.executeActions(transition == null ? void 0 : transition.actions, event);
+    });
+    __publicField(this, "performStateChangeEffects", (current, next, event) => {
+      this.setEvent(event);
+      const changed = next.changed || next.reenter;
+      if (changed) {
+        this.performExitEffects(current, event);
+      }
+      this.performTransitionEffects(next.transition, event);
+      this.setState(next.target);
+      if (changed) {
+        this.performEntryEffects(next.target, event);
+      }
+    });
+    __publicField(this, "determineTransition", (transition, event) => {
+      const fn = determineTransitionFn(transition, this.guardMap);
+      return fn == null ? void 0 : fn(this.contextSnapshot, event, this.guardMeta);
+    });
+    __publicField(this, "sendParent", (evt) => {
+      var _a2;
+      if (!this.parent) {
+        invariant("[@zag-js/core > send-parent] Cannot send event to an unknown parent");
+      }
+      const event = toEvent(evt);
+      (_a2 = this.parent) == null ? void 0 : _a2.send(event);
+    });
+    __publicField(this, "log", (...args) => {
+      if (isDev2() && this.options.debug) {
+        console.log(...args);
+      }
+    });
+    __publicField(this, "send", (evt) => {
+      const event = toEvent(evt);
+      this.transition(this.state.value, event);
+    });
+    __publicField(this, "transition", (state, evt) => {
+      var _a2, _b2, _c2;
+      const stateNode = isString(state) ? this.getStateNode(state) : state == null ? void 0 : state.stateNode;
+      const event = toEvent(evt);
+      if (!stateNode && !this.config.on) {
+        const msg = this.status === "Stopped" ? "[@zag-js/core > transition] Cannot transition a stopped machine" : `[@zag-js/core > transition] State does not have a definition for \`state\`: ${state}, \`event\`: ${event.type}`;
+        warn(msg);
+        return;
+      }
+      const transitions = (
+        // @ts-expect-error - Fix this
+        (_c2 = (_a2 = stateNode == null ? void 0 : stateNode.on) == null ? void 0 : _a2[event.type]) != null ? _c2 : (_b2 = this.config.on) == null ? void 0 : _b2[event.type]
+      );
+      const next = this.getNextStateInfo(transitions, event);
+      this.performStateChangeEffects(this.state.value, next, event);
+      return next.stateNode;
+    });
+    __publicField(this, "subscribe", (listener) => {
+      this.stateListeners.add(listener);
+      if (this.status === "Running") {
+        listener(this.stateSnapshot);
+      }
+      return () => {
+        this.stateListeners.delete(listener);
+      };
+    });
+    __publicField(this, "onDone", (listener) => {
+      this.doneListeners.add(listener);
+      return this;
+    });
+    __publicField(this, "onTransition", (listener) => {
+      this.stateListeners.add(listener);
+      if (this.status === "Running") {
+        listener(this.stateSnapshot);
+      }
+      return this;
+    });
+    this.config = structuredClone(config);
+    this.options = structuredClone(options != null ? options : {});
+    this.id = (_a = this.config.id) != null ? _a : `machine-${uuid()}`;
+    this.guardMap = (_c = (_b = this.options) == null ? void 0 : _b.guards) != null ? _c : {};
+    this.actionMap = (_e = (_d = this.options) == null ? void 0 : _d.actions) != null ? _e : {};
+    this.delayMap = (_g = (_f = this.options) == null ? void 0 : _f.delays) != null ? _g : {};
+    this.activityMap = (_i = (_h = this.options) == null ? void 0 : _h.activities) != null ? _i : {};
+    this.sync = (_k = (_j = this.options) == null ? void 0 : _j.sync) != null ? _k : false;
+    this.state = createProxy2(this.config);
+    this.initialContext = snapshot(this.state.context);
+  }
+  // immutable state value
+  get stateSnapshot() {
+    return cast(snapshot(this.state));
+  }
+  getState() {
+    return this.stateSnapshot;
+  }
+  // immutable context value
+  get contextSnapshot() {
+    return this.stateSnapshot.context;
+  }
+  /**
+   * A reference to the instance methods of the machine.
+   * Useful when spawning child machines and managing the communication between them.
+   */
+  get self() {
+    const self2 = this;
+    return {
+      id: this.id,
+      send: this.send.bind(this),
+      sendParent: this.sendParent.bind(this),
+      sendChild: this.sendChild.bind(this),
+      stop: this.stop.bind(this),
+      stopChild: this.stopChild.bind(this),
+      spawn: this.spawn.bind(this),
+      stopActivity: this.stopActivity.bind(this),
+      get state() {
+        return self2.stateSnapshot;
+      },
+      get initialContext() {
+        return self2.initialContext;
+      },
+      get initialState() {
+        var _a, _b;
+        return (_b = (_a = self2.initialState) == null ? void 0 : _a.target) != null ? _b : "";
+      }
+    };
+  }
+  get meta() {
+    var _a, _b;
+    return {
+      state: this.stateSnapshot,
+      guards: this.guardMap,
+      send: this.send.bind(this),
+      self: this.self,
+      initialContext: this.initialContext,
+      initialState: (_b = (_a = this.initialState) == null ? void 0 : _a.target) != null ? _b : "",
+      getState: () => this.stateSnapshot,
+      getAction: (key) => this.actionMap[key],
+      getGuard: (key) => this.guardMap[key]
+    };
+  }
+  get guardMeta() {
+    return {
+      state: this.stateSnapshot
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return "Machine";
+  }
+  getHydrationState() {
+    const state = this.getState();
+    return {
+      value: state.value,
+      tags: state.tags
+    };
+  }
+};
+var createMachine = (config, options) => new Machine(config, options);
+var clsx = (...args) => args.map((str) => {
+  var _a;
+  return (_a = str == null ? void 0 : str.trim) == null ? void 0 : _a.call(str);
+}).filter(Boolean).join(" ");
+var CSS_REGEX = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+var serialize = (style) => {
+  const res = {};
+  let match;
+  while (match = CSS_REGEX.exec(style)) {
+    res[match[1]] = match[2];
+  }
+  return res;
+};
+var css = (a, b) => {
+  if (isString(a)) {
+    if (isString(b)) return `${a};${b}`;
+    a = serialize(a);
+  } else if (isString(b)) {
+    b = serialize(b);
+  }
+  return Object.assign({}, a != null ? a : {}, b != null ? b : {});
+};
+function mergeProps(...args) {
+  let result = {};
+  for (let props2 of args) {
+    for (let key in result) {
+      if (key.startsWith("on") && typeof result[key] === "function" && typeof props2[key] === "function") {
+        result[key] = callAll(props2[key], result[key]);
+        continue;
+      }
+      if (key === "className" || key === "class") {
+        result[key] = clsx(result[key], props2[key]);
+        continue;
+      }
+      if (key === "style") {
+        result[key] = css(result[key], props2[key]);
+        continue;
+      }
+      result[key] = props2[key] !== void 0 ? props2[key] : result[key];
+    }
+    for (let key in props2) {
+      if (result[key] === void 0) {
+        result[key] = props2[key];
+      }
+    }
+  }
+  return result;
+}
+
+// ../../node_modules/@ark-ui/react/dist/components/factory.js
+var import_react = require("react");
+function getRef(element) {
+  var _a, _b;
+  let getter = (_a = Object.getOwnPropertyDescriptor(element.props, "ref")) == null ? void 0 : _a.get;
+  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.ref;
+  }
+  getter = (_b = Object.getOwnPropertyDescriptor(element, "ref")) == null ? void 0 : _b.get;
+  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.props.ref;
+  }
+  return element.props.ref || element.ref;
+}
+var withAsChild = (Component) => {
+  const Comp = (0, import_react.memo)(
+    (0, import_react.forwardRef)((props2, ref2) => {
+      const { asChild, children, ...restProps } = props2;
+      if (!asChild) {
+        return (0, import_react.createElement)(Component, { ...restProps, ref: ref2 }, children);
+      }
+      const onlyChild = import_react.Children.only(children);
+      if (!(0, import_react.isValidElement)(onlyChild)) {
+        return null;
+      }
+      const childRef = getRef(onlyChild);
+      return (0, import_react.cloneElement)(onlyChild, {
+        ...mergeProps(restProps, onlyChild.props),
+        ref: ref2 ? composeRefs(ref2, childRef) : childRef
+      });
+    })
+  );
+  Comp.displayName = Component.displayName || Component.name;
+  return Comp;
+};
+var jsxFactory = () => {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(withAsChild, {
+    apply(_target, _thisArg, argArray) {
+      return withAsChild(argArray[0]);
+    },
+    get(_, element) {
+      const asElement = element;
+      if (!cache.has(asElement)) {
+        cache.set(asElement, withAsChild(asElement));
+      }
+      return cache.get(asElement);
+    }
+  });
+};
+var ark = jsxFactory();
+
+// ../../node_modules/@ark-ui/react/dist/utils/create-split-props.js
+var createSplitProps = () => (props2, keys) => keys.reduce(
+  (previousValue, currentValue) => {
+    const [target, source] = previousValue;
+    const key = currentValue;
+    if (source[key] !== void 0) {
+      target[key] = source[key];
+    }
+    delete source[key];
+    return [target, source];
+  },
+  [{}, { ...props2 }]
+);
+
+// ../../node_modules/@ark-ui/react/dist/components/presence/split-presence-props.js
+var splitPresenceProps = (props2) => createSplitProps()(props2, [
+  "immediate",
+  "lazyMount",
+  "onExitComplete",
+  "present",
+  "unmountOnExit"
+]);
+
+// ../../node_modules/@zag-js/types/dist/index.mjs
+function createNormalizer(fn) {
+  return new Proxy({}, {
+    get() {
+      return fn;
+    }
+  });
+}
+var createProps = () => (props2) => Array.from(new Set(props2));
+
+// ../../node_modules/@zag-js/presence/dist/index.mjs
+function connect(state, send, _normalize) {
+  const present = state.matches("mounted", "unmountSuspended");
+  return {
+    skip: !state.context.initial && present,
+    present,
+    setNode(node) {
+      if (!node) return;
+      send({ type: "NODE.SET", node });
+    },
+    unmount() {
+      send({ type: "UNMOUNT" });
+    }
+  };
+}
+function machine(ctx) {
+  return createMachine(
+    {
+      initial: ctx.present ? "mounted" : "unmounted",
+      context: {
+        node: null,
+        styles: null,
+        unmountAnimationName: null,
+        prevAnimationName: null,
+        present: false,
+        initial: false,
+        ...ctx
+      },
+      exit: ["clearInitial"],
+      watch: {
+        present: ["setInitial", "syncPresence"]
+      },
+      on: {
+        "NODE.SET": {
+          actions: ["setNode", "setStyles"]
+        }
+      },
+      states: {
+        mounted: {
+          on: {
+            UNMOUNT: {
+              target: "unmounted",
+              actions: ["invokeOnExitComplete"]
+            },
+            "UNMOUNT.SUSPEND": "unmountSuspended"
+          }
+        },
+        unmountSuspended: {
+          activities: ["trackAnimationEvents"],
+          after: {
+            // Fallback to timeout to ensure we exit this state even if the `animationend` event
+            // did not get trigger
+            ANIMATION_DURATION: {
+              target: "unmounted",
+              actions: ["invokeOnExitComplete"]
+            }
+          },
+          on: {
+            MOUNT: {
+              target: "mounted",
+              actions: ["setPrevAnimationName"]
+            },
+            UNMOUNT: {
+              target: "unmounted",
+              actions: ["invokeOnExitComplete"]
+            }
+          }
+        },
+        unmounted: {
+          entry: ["clearPrevAnimationName"],
+          on: {
+            MOUNT: {
+              target: "mounted",
+              actions: ["setPrevAnimationName"]
+            }
+          }
+        }
+      }
+    },
+    {
+      delays: {
+        ANIMATION_DURATION(ctx2) {
+          var _a, _b;
+          return parseMs((_a = ctx2.styles) == null ? void 0 : _a.animationDuration) + parseMs((_b = ctx2.styles) == null ? void 0 : _b.animationDelay) + ANIMATION_TIMEOUT_MARGIN;
+        }
+      },
+      actions: {
+        setInitial(ctx2) {
+          ctx2.initial = true;
+        },
+        clearInitial(ctx2) {
+          ctx2.initial = false;
+        },
+        invokeOnExitComplete(ctx2) {
+          var _a;
+          (_a = ctx2.onExitComplete) == null ? void 0 : _a.call(ctx2);
+        },
+        setNode(ctx2, evt) {
+          ctx2.node = ref(evt.node);
+        },
+        setStyles(ctx2, evt) {
+          const win = evt.node.ownerDocument.defaultView || window;
+          ctx2.styles = ref(win.getComputedStyle(evt.node));
+        },
+        syncPresence(ctx2, _evt, { send }) {
+          var _a;
+          if (ctx2.present) {
+            send({ type: "MOUNT", src: "presence.changed" });
+            return;
+          }
+          if (!ctx2.present && ((_a = ctx2.node) == null ? void 0 : _a.ownerDocument.visibilityState) === "hidden") {
+            send({ type: "UNMOUNT", src: "visibilitychange" });
+            return;
+          }
+          const animationName = getAnimationName(ctx2.styles);
+          const exec = ctx2.immediate ? queueMicrotask : requestAnimationFrame;
+          exec(() => {
+            var _a2, _b;
+            ctx2.unmountAnimationName = animationName;
+            if (animationName === "none" || animationName === ctx2.prevAnimationName || ((_a2 = ctx2.styles) == null ? void 0 : _a2.display) === "none" || ((_b = ctx2.styles) == null ? void 0 : _b.animationDuration) === "0s") {
+              send({ type: "UNMOUNT", src: "presence.changed" });
+            } else {
+              send({ type: "UNMOUNT.SUSPEND" });
+            }
+          });
+        },
+        setPrevAnimationName(ctx2) {
+          const exec = ctx2.immediate ? queueMicrotask : requestAnimationFrame;
+          exec(() => {
+            ctx2.prevAnimationName = getAnimationName(ctx2.styles);
+          });
+        },
+        clearPrevAnimationName(ctx2) {
+          ctx2.prevAnimationName = null;
+        }
+      },
+      activities: {
+        trackAnimationEvents(ctx2, _evt, { send }) {
+          const node = ctx2.node;
+          if (!node) return;
+          const onStart = (event) => {
+            var _a, _b, _c;
+            const target = (_c = (_b = (_a = event.composedPath) == null ? void 0 : _a.call(event)) == null ? void 0 : _b[0]) != null ? _c : event.target;
+            if (target === node) {
+              ctx2.prevAnimationName = getAnimationName(ctx2.styles);
+            }
+          };
+          const onEnd = (event) => {
+            var _a, _b, _c;
+            const animationName = getAnimationName(ctx2.styles);
+            const target = (_c = (_b = (_a = event.composedPath) == null ? void 0 : _a.call(event)) == null ? void 0 : _b[0]) != null ? _c : event.target;
+            if (target === node && animationName === ctx2.unmountAnimationName) {
+              send({ type: "UNMOUNT", src: "animationend" });
+            }
+          };
+          node.addEventListener("animationstart", onStart);
+          node.addEventListener("animationcancel", onEnd);
+          node.addEventListener("animationend", onEnd);
+          return () => {
+            node.removeEventListener("animationstart", onStart);
+            node.removeEventListener("animationcancel", onEnd);
+            node.removeEventListener("animationend", onEnd);
+          };
+        }
+      }
+    }
+  );
+}
+function getAnimationName(styles) {
+  return (styles == null ? void 0 : styles.animationName) || "none";
+}
+function parseMs(value) {
+  return parseFloat(value || "0") * 1e3;
+}
+var ANIMATION_TIMEOUT_MARGIN = 16.667;
+var props = createProps()(["onExitComplete", "present", "immediate"]);
+
+// ../../node_modules/@zag-js/react/dist/index.mjs
+var import_react2 = __toESM(require("react"), 1);
+var import_react_dom = require("react-dom");
+var import_jsx_runtime = require("react/jsx-runtime");
+var normalizeProps = createNormalizer((v) => v);
+var isArrayLike = (value) => (value == null ? void 0 : value.constructor.name) === "Array";
+var isArrayEqual = (a, b) => {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!isEqual(a[i], b[i])) return false;
+  }
+  return true;
+};
+var isEqual = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (a == null && b != null || a != null && b == null) return false;
+  if (typeof (a == null ? void 0 : a.isEqual) === "function" && typeof (b == null ? void 0 : b.isEqual) === "function") {
+    return a.isEqual(b);
+  }
+  if (typeof a === "function" && typeof b === "function") {
+    return a.toString() === b.toString();
+  }
+  if (isArrayLike(a) && isArrayLike(b)) {
+    return isArrayEqual(Array.from(a), Array.from(b));
+  }
+  if (!(typeof a === "object") || !(typeof b === "object")) return false;
+  const keys = Object.keys(b != null ? b : /* @__PURE__ */ Object.create(null));
+  const length = keys.length;
+  for (let i = 0; i < length; i++) {
+    const hasKey = Reflect.has(a, keys[i]);
+    if (!hasKey) return false;
+  }
+  for (let i = 0; i < length; i++) {
+    const key = keys[i];
+    if (!isEqual(a[key], b[key])) return false;
+  }
+  return true;
+};
+var isDev3 = () => process.env.NODE_ENV !== "production";
+var fnToString2 = Function.prototype.toString;
+fnToString2.call(Object);
+function compact2(obj) {
+  if (!isPlainObject3(obj) || obj === void 0) {
+    return obj;
+  }
+  const keys = Reflect.ownKeys(obj).filter((key) => typeof key === "string");
+  const filtered = {};
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      filtered[key] = compact2(value);
+    }
+  }
+  return filtered;
+}
+var isPlainObject3 = (value) => {
+  return value && typeof value === "object" && value.constructor === Object;
+};
+function useUpdateEffect(callback, deps) {
+  const render = (0, import_react2.useRef)(false);
+  const effect = (0, import_react2.useRef)(false);
+  (0, import_react2.useEffect)(() => {
+    const mounted = render.current;
+    const run = mounted && effect.current;
+    if (run) {
+      return callback();
+    }
+    effect.current = true;
+  }, deps);
+  (0, import_react2.useEffect)(() => {
+    render.current = true;
+    return () => {
+      render.current = false;
+    };
+  }, []);
+}
+var { use } = import_react2.default;
+var targetCache = makeGlobal("__zag__targetCache", () => /* @__PURE__ */ new WeakMap());
+function useSnapshot(service, options) {
+  const { actions, context, sync: notifyInSync } = options != null ? options : {};
+  const lastSnapshot = (0, import_react2.useRef)();
+  const lastAffected = (0, import_react2.useRef)();
+  const currSnapshot = (0, import_react2.useSyncExternalStore)(
+    (0, import_react2.useCallback)((callback) => subscribe(service.state, callback, notifyInSync), [notifyInSync]),
+    () => {
+      const nextSnapshot = snapshot(service.state, use);
+      try {
+        if (lastSnapshot.current && lastAffected.current && !isChanged(lastSnapshot.current, nextSnapshot, lastAffected.current, /* @__PURE__ */ new WeakMap())) {
+          return lastSnapshot.current;
+        }
+      } catch {
+      }
+      return nextSnapshot;
+    },
+    () => snapshot(service.state, use)
+  );
+  service.setOptions({ actions });
+  const ctx = (0, import_react2.useMemo)(() => compact2(context != null ? context : {}), [context]);
+  useUpdateEffect(() => {
+    var _a;
+    const entries = Object.entries(ctx);
+    const previousCtx = (_a = service.contextSnapshot) != null ? _a : {};
+    const equality = entries.map(([key, value]) => ({
+      key,
+      curr: value,
+      prev: previousCtx[key],
+      equal: isEqual(previousCtx[key], value)
+    }));
+    const allEqual = equality.every(({ equal }) => equal);
+    if (!allEqual) {
+      service.setContext(ctx);
+    }
+  }, [ctx]);
+  const currAffected = /* @__PURE__ */ new WeakMap();
+  (0, import_react2.useEffect)(() => {
+    lastSnapshot.current = currSnapshot;
+    lastAffected.current = currAffected;
+  });
+  const proxyCache = (0, import_react2.useMemo)(() => /* @__PURE__ */ new WeakMap(), []);
+  return createProxy(currSnapshot, currAffected, proxyCache, targetCache);
+}
+function useConstant(fn) {
+  const ref2 = (0, import_react2.useRef)();
+  if (!ref2.current) ref2.current = { v: fn() };
+  return ref2.current.v;
+}
+var useSafeLayoutEffect = typeof document !== "undefined" ? import_react2.useLayoutEffect : import_react2.useEffect;
+function useService(machine2, options) {
+  const { state: hydratedState, context } = options != null ? options : {};
+  const service = useConstant(() => {
+    const instance = typeof machine2 === "function" ? machine2() : machine2;
+    if (context) instance.setContext(context);
+    instance._created();
+    return instance;
+  });
+  const snapshotRef = (0, import_react2.useRef)();
+  useSafeLayoutEffect(() => {
+    const stateInit = hydratedState != null ? hydratedState : snapshotRef.current;
+    service.start(stateInit);
+    return () => {
+      if (isDev3()) {
+        snapshotRef.current = service.getHydrationState();
+      }
+      service.stop();
+    };
+  }, []);
+  return service;
+}
+function useMachine(machine2, options) {
+  const service = useService(machine2, options);
+  const state = useSnapshot(service, options);
+  return [state, service.send, service];
+}
+
+// ../../node_modules/@ark-ui/react/dist/components/presence/use-presence.js
+var import_react5 = require("react");
+
+// ../../node_modules/@ark-ui/react/dist/utils/use-event.js
+var import_react3 = require("react");
+function useEvent(callback, opts = {}) {
+  const { sync = false } = opts;
+  const callbackRef = useLatestRef(callback);
+  return (0, import_react3.useCallback)(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    (...args) => {
+      var _a;
+      if (sync) return queueMicrotask(() => {
+        var _a2;
+        return (_a2 = callbackRef.current) == null ? void 0 : _a2.call(callbackRef, ...args);
+      });
+      return (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, ...args);
+    },
+    [sync, callbackRef]
+  );
+}
+function useLatestRef(value) {
+  const ref2 = (0, import_react3.useRef)(value);
+  ref2.current = value;
+  return ref2;
+}
+
+// ../../node_modules/@ark-ui/react/dist/components/presence/use-presence.js
+var usePresence = (props2) => {
+  const { lazyMount, unmountOnExit, ...rest } = props2;
+  const wasEverPresent = (0, import_react5.useRef)(false);
+  const context = {
+    ...rest,
+    onExitComplete: useEvent(props2.onExitComplete)
+  };
+  const [state, send] = useMachine(machine(context), { context });
+  const api = connect(state, send, normalizeProps);
+  if (api.present) {
+    wasEverPresent.current = true;
+  }
+  const unmounted = !api.present && !wasEverPresent.current && lazyMount || unmountOnExit && !api.present && wasEverPresent.current;
+  const getPresenceProps = () => ({
+    "data-state": props2.present ? "open" : "closed",
+    hidden: !api.present
+  });
+  return {
+    ref: api.setNode,
+    getPresenceProps,
+    present: api.present,
+    unmounted
+  };
+};
+
+// ../../node_modules/@ark-ui/react/dist/components/presence/presence.js
+var Presence = (0, import_react6.forwardRef)((props2, ref2) => {
+  const [presenceProps, localProps] = splitPresenceProps(props2);
+  const presence = usePresence(presenceProps);
+  if (presence.unmounted) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    ark.div,
+    {
+      ...localProps,
+      ...presence.getPresenceProps(),
+      "data-scope": "presence",
+      "data-part": "root",
+      ref: composeRefs(presence.ref, ref2)
+    }
+  );
+});
+Presence.displayName = "Presence";
+
+// src/components/loading-overlay/loading-overlay.tsx
+var import_react9 = require("@chakra-ui/react");
+
+// src/components/spinner/spinner.tsx
+var import_react7 = require("react");
+var import_react8 = require("@chakra-ui/react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var Spinner = (0, import_react7.forwardRef)(
+  function Spinner2(props2, ref2) {
+    const { loading, children, ...rest } = props2;
+    if (loading === false) {
+      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react8.Spinner, { ref: ref2, ...rest });
+  }
+);
+
+// src/components/loading-overlay/loading-overlay.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var { useStyles, withContext, withProvider } = (0, import_react9.createSlotRecipeContext)({
+  key: "loadingOverlay"
+});
+var LoadingOverlay = (props2) => {
+  const { children, loading = true, ...rest } = props2;
+  const [presenceProps, rootProps] = splitPresenceProps(rest);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Presence, { present: loading, ...presenceProps, asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react9.chakra.div, { ...rootProps, children }) });
+};
+var LoadingOverlayRoot = withProvider(LoadingOverlay, "root");
+LoadingOverlayRoot.displayName = "LoadingOverlay";
+var LoadingOverlaySpinner = Spinner;
+var LoadingOverlayText = withContext("p", "text");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoadingOverlay
+});