sanity 3.94.1-next.5.ec6157041e → 3.94.1

package/dist/index-DCkQlgdi.mjs

@@ -0,0 +1,4001 @@
+import lt, { useLayoutEffect as Jt, useCallback as Je, useEffect as Ne, useState as Nt, forwardRef as pt } from "react";
+import { v as Xt, f as yt, b as Oe, x as Yt, y as Ie, z as Kt, t as Zt } from "./index-RoxwhtVB.mjs";
+import { o as Ft, c as Qt, m as Ae, y as Ce } from "./v4-zH-CAum7.mjs";
+import { b as ye, a as en, p as ge } from "./Observable-CCQtH8Gg.mjs";
+import { jsxs as gt, jsx as R } from "react/jsx-runtime";
+function tn(e, t) {
+  return t === void 0 && (t = null), t = t ?? e, Ft(function(n, s) {
+    var r = [], i = 0;
+    n.subscribe(Qt(s, function(o) {
+      var a, d, h, y, u = null;
+      i++ % t === 0 && r.push([]);
+      try {
+        for (var c = ye(r), l = c.next(); !l.done; l = c.next()) {
+          var f = l.value;
+          f.push(o), e <= f.length && (u = u ?? [], u.push(f));
+        }
+      } catch (m) {
+        a = { error: m };
+      } finally {
+        try {
+          l && !l.done && (d = c.return) && d.call(c);
+        } finally {
+          if (a) throw a.error;
+        }
+      }
+      if (u)
+        try {
+          for (var p = ye(u), g = p.next(); !g.done; g = p.next()) {
+            var f = g.value;
+            en(r, f), s.next(f);
+          }
+        } catch (m) {
+          h = { error: m };
+        } finally {
+          try {
+            g && !g.done && (y = p.return) && y.call(p);
+          } finally {
+            if (h) throw h.error;
+          }
+        }
+    }, function() {
+      var o, a;
+      try {
+        for (var d = ye(r), h = d.next(); !h.done; h = d.next()) {
+          var y = h.value;
+          s.next(y);
+        }
+      } catch (u) {
+        o = { error: u };
+      } finally {
+        try {
+          h && !h.done && (a = d.return) && a.call(d);
+        } finally {
+          if (o) throw o.error;
+        }
+      }
+      s.complete();
+    }, void 0, function() {
+      r = null;
+    }));
+  });
+}
+var nn = Jt;
+function sn() {
+  if (typeof globalThis < "u")
+    return globalThis;
+  if (typeof self < "u")
+    return self;
+  if (typeof window < "u")
+    return window;
+  if (typeof global < "u")
+    return global;
+}
+function rn() {
+  const e = sn();
+  if (e.__xstate__)
+    return e.__xstate__;
+}
+const on = (e) => {
+  if (typeof window > "u")
+    return;
+  const t = rn();
+  t && t.register(e);
+};
+class Xe {
+  constructor(t) {
+    this._process = t, this._active = !1, this._current = null, this._last = null;
+  }
+  start() {
+    this._active = !0, this.flush();
+  }
+  clear() {
+    this._current && (this._current.next = null, this._last = this._current);
+  }
+  enqueue(t) {
+    const n = {
+      value: t,
+      next: null
+    };
+    if (this._current) {
+      this._last.next = n, this._last = n;
+      return;
+    }
+    this._current = n, this._last = n, this._active && this.flush();
+  }
+  flush() {
+    for (; this._current; ) {
+      const t = this._current;
+      this._process(t.value), this._current = t.next;
+    }
+    this._last = null;
+  }
+}
+const mt = ".", an = "", vt = "", cn = "#", un = "*", _t = "xstate.init", dn = "xstate.error", j = "xstate.stop";
+function fn(e, t) {
+  return {
+    type: `xstate.after.${e}.${t}`
+  };
+}
+function Re(e, t) {
+  return {
+    type: `xstate.done.state.${e}`,
+    output: t
+  };
+}
+function hn(e, t) {
+  return {
+    type: `xstate.done.actor.${e}`,
+    output: t,
+    actorId: e
+  };
+}
+function St(e, t) {
+  return {
+    type: `xstate.error.actor.${e}`,
+    error: t,
+    actorId: e
+  };
+}
+function bt(e) {
+  return {
+    type: _t,
+    input: e
+  };
+}
+function k(e) {
+  setTimeout(() => {
+    throw e;
+  });
+}
+const ln = typeof Symbol == "function" && Symbol.observable || "@@observable";
+function wt(e, t) {
+  const n = Ye(e), s = Ye(t);
+  return typeof s == "string" ? typeof n == "string" ? s === n : !1 : typeof n == "string" ? n in s : Object.keys(n).every((r) => r in s ? wt(n[r], s[r]) : !1);
+}
+function je(e) {
+  if (Tt(e))
+    return e;
+  const t = [];
+  let n = "";
+  for (let s = 0; s < e.length; s++) {
+    switch (e.charCodeAt(s)) {
+      // \
+      case 92:
+        n += e[s + 1], s++;
+        continue;
+      // .
+      case 46:
+        t.push(n), n = "";
+        continue;
+    }
+    n += e[s];
+  }
+  return t.push(n), t;
+}
+function Ye(e) {
+  if (Xn(e))
+    return e.value;
+  if (typeof e != "string")
+    return e;
+  const t = je(e);
+  return pn(t);
+}
+function pn(e) {
+  if (e.length === 1)
+    return e[0];
+  const t = {};
+  let n = t;
+  for (let s = 0; s < e.length - 1; s++)
+    if (s === e.length - 2)
+      n[e[s]] = e[s + 1];
+    else {
+      const r = n;
+      n = {}, r[e[s]] = n;
+    }
+  return t;
+}
+function Ke(e, t) {
+  const n = {}, s = Object.keys(e);
+  for (let r = 0; r < s.length; r++) {
+    const i = s[r];
+    n[i] = t(e[i], i, e, r);
+  }
+  return n;
+}
+function Et(e) {
+  return Tt(e) ? e : [e];
+}
+function C(e) {
+  return e === void 0 ? [] : Et(e);
+}
+function Me(e, t, n, s) {
+  return typeof e == "function" ? e({
+    context: t,
+    event: n,
+    self: s
+  }) : e;
+}
+function Tt(e) {
+  return Array.isArray(e);
+}
+function yn(e) {
+  return e.type.startsWith("xstate.error.actor");
+}
+function U(e) {
+  return Et(e).map((t) => typeof t > "u" || typeof t == "string" ? {
+    target: t
+  } : t);
+}
+function xt(e) {
+  if (!(e === void 0 || e === an))
+    return C(e);
+}
+function ae(e, t, n) {
+  var i, o, a;
+  const s = typeof e == "object", r = s ? e : void 0;
+  return {
+    next: (i = s ? e.next : e) == null ? void 0 : i.bind(r),
+    error: (o = s ? e.error : t) == null ? void 0 : o.bind(r),
+    complete: (a = s ? e.complete : n) == null ? void 0 : a.bind(r)
+  };
+}
+function Ze(e, t) {
+  return `${t}.${e}`;
+}
+function De(e, t) {
+  const n = t.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+  if (!n)
+    return e.implementations.actors[t];
+  const [, s, r] = n, o = e.getStateNodeById(r).config.invoke;
+  return (Array.isArray(o) ? o[s] : o).src;
+}
+function Fe(e, t) {
+  return `${e.sessionId}.${t}`;
+}
+let gn = 0;
+function mn(e, t) {
+  const n = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new WeakMap(), i = /* @__PURE__ */ new Set(), o = {}, {
+    clock: a,
+    logger: d
+  } = t, h = {
+    schedule: (c, l, f, p, g = Math.random().toString(36).slice(2)) => {
+      const m = {
+        source: c,
+        target: l,
+        event: f,
+        delay: p,
+        id: g,
+        startedAt: Date.now()
+      }, v = Fe(c, g);
+      u._snapshot._scheduledEvents[v] = m;
+      const _ = a.setTimeout(() => {
+        delete o[v], delete u._snapshot._scheduledEvents[v], u._relay(c, l, f);
+      }, p);
+      o[v] = _;
+    },
+    cancel: (c, l) => {
+      const f = Fe(c, l), p = o[f];
+      delete o[f], delete u._snapshot._scheduledEvents[f], p !== void 0 && a.clearTimeout(p);
+    },
+    cancelAll: (c) => {
+      for (const l in u._snapshot._scheduledEvents) {
+        const f = u._snapshot._scheduledEvents[l];
+        f.source === c && h.cancel(c, f.id);
+      }
+    }
+  }, y = (c) => {
+    if (!i.size)
+      return;
+    const l = {
+      ...c,
+      rootId: e.sessionId
+    };
+    i.forEach((f) => {
+      var p;
+      return (p = f.next) == null ? void 0 : p.call(f, l);
+    });
+  }, u = {
+    _snapshot: {
+      _scheduledEvents: ((t == null ? void 0 : t.snapshot) && t.snapshot.scheduler) ?? {}
+    },
+    _bookId: () => `x:${gn++}`,
+    _register: (c, l) => (n.set(c, l), c),
+    _unregister: (c) => {
+      n.delete(c.sessionId);
+      const l = r.get(c);
+      l !== void 0 && (s.delete(l), r.delete(c));
+    },
+    get: (c) => s.get(c),
+    _set: (c, l) => {
+      const f = s.get(c);
+      if (f && f !== l)
+        throw new Error(`Actor with system ID '${c}' already exists.`);
+      s.set(c, l), r.set(l, c);
+    },
+    inspect: (c) => {
+      const l = ae(c);
+      return i.add(l), {
+        unsubscribe() {
+          i.delete(l);
+        }
+      };
+    },
+    _sendInspectionEvent: y,
+    _relay: (c, l, f) => {
+      u._sendInspectionEvent({
+        type: "@xstate.event",
+        sourceRef: c,
+        actorRef: l,
+        event: f
+      }), l._send(f);
+    },
+    scheduler: h,
+    getSnapshot: () => ({
+      _scheduledEvents: {
+        ...u._snapshot._scheduledEvents
+      }
+    }),
+    start: () => {
+      const c = u._snapshot._scheduledEvents;
+      u._snapshot._scheduledEvents = {};
+      for (const l in c) {
+        const {
+          source: f,
+          target: p,
+          event: g,
+          delay: m,
+          id: v
+        } = c[l];
+        h.schedule(f, p, g, m, v);
+      }
+    },
+    _clock: a,
+    _logger: d
+  };
+  return u;
+}
+let me = !1;
+const Ve = 1;
+let E = /* @__PURE__ */ function(e) {
+  return e[e.NotStarted = 0] = "NotStarted", e[e.Running = 1] = "Running", e[e.Stopped = 2] = "Stopped", e;
+}({});
+const vn = {
+  clock: {
+    setTimeout: (e, t) => setTimeout(e, t),
+    clearTimeout: (e) => clearTimeout(e)
+  },
+  logger: console.log.bind(console),
+  devTools: !1
+};
+class _n {
+  /**
+   * Creates a new actor instance for the given logic with the provided options,
+   * if any.
+   *
+   * @param logic The logic to create an actor from
+   * @param options Actor options
+   */
+  constructor(t, n) {
+    this.logic = t, this._snapshot = void 0, this.clock = void 0, this.options = void 0, this.id = void 0, this.mailbox = new Xe(this._process.bind(this)), this.observers = /* @__PURE__ */ new Set(), this.eventListeners = /* @__PURE__ */ new Map(), this.logger = void 0, this._processingStatus = E.NotStarted, this._parent = void 0, this._syncSnapshot = void 0, this.ref = void 0, this._actorScope = void 0, this._systemId = void 0, this.sessionId = void 0, this.system = void 0, this._doneEvent = void 0, this.src = void 0, this._deferred = [];
+    const s = {
+      ...vn,
+      ...n
+    }, {
+      clock: r,
+      logger: i,
+      parent: o,
+      syncSnapshot: a,
+      id: d,
+      systemId: h,
+      inspect: y
+    } = s;
+    this.system = o ? o.system : mn(this, {
+      clock: r,
+      logger: i
+    }), y && !o && this.system.inspect(ae(y)), this.sessionId = this.system._bookId(), this.id = d ?? this.sessionId, this.logger = (n == null ? void 0 : n.logger) ?? this.system._logger, this.clock = (n == null ? void 0 : n.clock) ?? this.system._clock, this._parent = o, this._syncSnapshot = a, this.options = s, this.src = s.src ?? t, this.ref = this, this._actorScope = {
+      self: this,
+      id: this.id,
+      sessionId: this.sessionId,
+      logger: this.logger,
+      defer: (u) => {
+        this._deferred.push(u);
+      },
+      system: this.system,
+      stopChild: (u) => {
+        if (u._parent !== this)
+          throw new Error(`Cannot stop child actor ${u.id} of ${this.id} because it is not a child`);
+        u._stop();
+      },
+      emit: (u) => {
+        const c = this.eventListeners.get(u.type), l = this.eventListeners.get("*");
+        if (!c && !l)
+          return;
+        const f = [...c ? c.values() : [], ...l ? l.values() : []];
+        for (const p of f)
+          p(u);
+      },
+      actionExecutor: (u) => {
+        const c = () => {
+          if (this._actorScope.system._sendInspectionEvent({
+            type: "@xstate.action",
+            actorRef: this,
+            action: {
+              type: u.type,
+              params: u.params
+            }
+          }), !u.exec)
+            return;
+          const l = me;
+          try {
+            me = !0, u.exec(u.info, u.params);
+          } finally {
+            me = l;
+          }
+        };
+        this._processingStatus === E.Running ? c() : this._deferred.push(c);
+      }
+    }, this.send = this.send.bind(this), this.system._sendInspectionEvent({
+      type: "@xstate.actor",
+      actorRef: this
+    }), h && (this._systemId = h, this.system._set(h, this)), this._initState((n == null ? void 0 : n.snapshot) ?? (n == null ? void 0 : n.state)), h && this._snapshot.status !== "active" && this.system._unregister(this);
+  }
+  _initState(t) {
+    var n;
+    try {
+      this._snapshot = t ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(t, this._actorScope) : t : this.logic.getInitialSnapshot(this._actorScope, (n = this.options) == null ? void 0 : n.input);
+    } catch (s) {
+      this._snapshot = {
+        status: "error",
+        output: void 0,
+        error: s
+      };
+    }
+  }
+  update(t, n) {
+    var r, i;
+    this._snapshot = t;
+    let s;
+    for (; s = this._deferred.shift(); )
+      try {
+        s();
+      } catch (o) {
+        this._deferred.length = 0, this._snapshot = {
+          ...t,
+          status: "error",
+          error: o
+        };
+      }
+    switch (this._snapshot.status) {
+      case "active":
+        for (const o of this.observers)
+          try {
+            (r = o.next) == null || r.call(o, t);
+          } catch (a) {
+            k(a);
+          }
+        break;
+      case "done":
+        for (const o of this.observers)
+          try {
+            (i = o.next) == null || i.call(o, t);
+          } catch (a) {
+            k(a);
+          }
+        this._stopProcedure(), this._complete(), this._doneEvent = hn(this.id, this._snapshot.output), this._parent && this.system._relay(this, this._parent, this._doneEvent);
+        break;
+      case "error":
+        this._error(this._snapshot.error);
+        break;
+    }
+    this.system._sendInspectionEvent({
+      type: "@xstate.snapshot",
+      actorRef: this,
+      event: n,
+      snapshot: t
+    });
+  }
+  /**
+   * Subscribe an observer to an actor’s snapshot values.
+   *
+   * @remarks
+   * The observer will receive the actor’s snapshot value when it is emitted.
+   * The observer can be:
+   *
+   * - A plain function that receives the latest snapshot, or
+   * - An observer object whose `.next(snapshot)` method receives the latest
+   *   snapshot
+   *
+   * @example
+   *
+   * ```ts
+   * // Observer as a plain function
+   * const subscription = actor.subscribe((snapshot) => {
+   *   console.log(snapshot);
+   * });
+   * ```
+   *
+   * @example
+   *
+   * ```ts
+   * // Observer as an object
+   * const subscription = actor.subscribe({
+   *   next(snapshot) {
+   *     console.log(snapshot);
+   *   },
+   *   error(err) {
+   *     // ...
+   *   },
+   *   complete() {
+   *     // ...
+   *   }
+   * });
+   * ```
+   *
+   * The return value of `actor.subscribe(observer)` is a subscription object
+   * that has an `.unsubscribe()` method. You can call
+   * `subscription.unsubscribe()` to unsubscribe the observer:
+   *
+   * @example
+   *
+   * ```ts
+   * const subscription = actor.subscribe((snapshot) => {
+   *   // ...
+   * });
+   *
+   * // Unsubscribe the observer
+   * subscription.unsubscribe();
+   * ```
+   *
+   * When the actor is stopped, all of its observers will automatically be
+   * unsubscribed.
+   *
+   * @param observer - Either a plain function that receives the latest
+   *   snapshot, or an observer object whose `.next(snapshot)` method receives
+   *   the latest snapshot
+   */
+  subscribe(t, n, s) {
+    var i;
+    const r = ae(t, n, s);
+    if (this._processingStatus !== E.Stopped)
+      this.observers.add(r);
+    else
+      switch (this._snapshot.status) {
+        case "done":
+          try {
+            (i = r.complete) == null || i.call(r);
+          } catch (o) {
+            k(o);
+          }
+          break;
+        case "error": {
+          const o = this._snapshot.error;
+          if (!r.error)
+            k(o);
+          else
+            try {
+              r.error(o);
+            } catch (a) {
+              k(a);
+            }
+          break;
+        }
+      }
+    return {
+      unsubscribe: () => {
+        this.observers.delete(r);
+      }
+    };
+  }
+  on(t, n) {
+    let s = this.eventListeners.get(t);
+    s || (s = /* @__PURE__ */ new Set(), this.eventListeners.set(t, s));
+    const r = n.bind(void 0);
+    return s.add(r), {
+      unsubscribe: () => {
+        s.delete(r);
+      }
+    };
+  }
+  /** Starts the Actor from the initial state */
+  start() {
+    if (this._processingStatus === E.Running)
+      return this;
+    this._syncSnapshot && this.subscribe({
+      next: (s) => {
+        s.status === "active" && this.system._relay(this, this._parent, {
+          type: `xstate.snapshot.${this.id}`,
+          snapshot: s
+        });
+      },
+      error: () => {
+      }
+    }), this.system._register(this.sessionId, this), this._systemId && this.system._set(this._systemId, this), this._processingStatus = E.Running;
+    const t = bt(this.options.input);
+    switch (this.system._sendInspectionEvent({
+      type: "@xstate.event",
+      sourceRef: this._parent,
+      actorRef: this,
+      event: t
+    }), this._snapshot.status) {
+      case "done":
+        return this.update(this._snapshot, t), this;
+      case "error":
+        return this._error(this._snapshot.error), this;
+    }
+    if (this._parent || this.system.start(), this.logic.start)
+      try {
+        this.logic.start(this._snapshot, this._actorScope);
+      } catch (s) {
+        return this._snapshot = {
+          ...this._snapshot,
+          status: "error",
+          error: s
+        }, this._error(s), this;
+      }
+    return this.update(this._snapshot, t), this.options.devTools && this.attachDevTools(), this.mailbox.start(), this;
+  }
+  _process(t) {
+    let n, s;
+    try {
+      n = this.logic.transition(this._snapshot, t, this._actorScope);
+    } catch (r) {
+      s = {
+        err: r
+      };
+    }
+    if (s) {
+      const {
+        err: r
+      } = s;
+      this._snapshot = {
+        ...this._snapshot,
+        status: "error",
+        error: r
+      }, this._error(r);
+      return;
+    }
+    this.update(n, t), t.type === j && (this._stopProcedure(), this._complete());
+  }
+  _stop() {
+    return this._processingStatus === E.Stopped ? this : (this.mailbox.clear(), this._processingStatus === E.NotStarted ? (this._processingStatus = E.Stopped, this) : (this.mailbox.enqueue({
+      type: j
+    }), this));
+  }
+  /** Stops the Actor and unsubscribe all listeners. */
+  stop() {
+    if (this._parent)
+      throw new Error("A non-root actor cannot be stopped directly.");
+    return this._stop();
+  }
+  _complete() {
+    var t;
+    for (const n of this.observers)
+      try {
+        (t = n.complete) == null || t.call(n);
+      } catch (s) {
+        k(s);
+      }
+    this.observers.clear();
+  }
+  _reportError(t) {
+    if (!this.observers.size) {
+      this._parent || k(t);
+      return;
+    }
+    let n = !1;
+    for (const s of this.observers) {
+      const r = s.error;
+      n || (n = !r);
+      try {
+        r == null || r(t);
+      } catch (i) {
+        k(i);
+      }
+    }
+    this.observers.clear(), n && k(t);
+  }
+  _error(t) {
+    this._stopProcedure(), this._reportError(t), this._parent && this.system._relay(this, this._parent, St(this.id, t));
+  }
+  // TODO: atm children don't belong entirely to the actor so
+  // in a way - it's not even super aware of them
+  // so we can't stop them from here but we really should!
+  // right now, they are being stopped within the machine's transition
+  // but that could throw and leave us with "orphaned" active actors
+  _stopProcedure() {
+    return this._processingStatus !== E.Running ? this : (this.system.scheduler.cancelAll(this), this.mailbox.clear(), this.mailbox = new Xe(this._process.bind(this)), this._processingStatus = E.Stopped, this.system._unregister(this), this);
+  }
+  /** @internal */
+  _send(t) {
+    this._processingStatus !== E.Stopped && this.mailbox.enqueue(t);
+  }
+  /**
+   * Sends an event to the running Actor to trigger a transition.
+   *
+   * @param event The event to send
+   */
+  send(t) {
+    this.system._relay(void 0, this, t);
+  }
+  attachDevTools() {
+    const {
+      devTools: t
+    } = this.options;
+    t && (typeof t == "function" ? t : on)(this);
+  }
+  toJSON() {
+    return {
+      xstate$$type: Ve,
+      id: this.id
+    };
+  }
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from
+   * {@link Actor.getSnapshot}. Persisted state represents the internal state of
+   * the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.state}
+   * @see https://stately.ai/docs/persistence
+   */
+  getPersistedSnapshot(t) {
+    return this.logic.getPersistedSnapshot(this._snapshot, t);
+  }
+  [ln]() {
+    return this;
+  }
+  /**
+   * Read an actor’s snapshot synchronously.
+   *
+   * @remarks
+   * The snapshot represent an actor's last emitted value.
+   *
+   * When an actor receives an event, its internal state may change. An actor
+   * may emit a snapshot when a state transition occurs.
+   *
+   * Note that some actors, such as callback actors generated with
+   * `fromCallback`, will not emit snapshots.
+   * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
+   * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
+   */
+  getSnapshot() {
+    return this._snapshot;
+  }
+}
+function $(e, ...[t]) {
+  return new _n(e, t);
+}
+function Sn(e, t, n, s, {
+  sendId: r
+}) {
+  const i = typeof r == "function" ? r(n, s) : r;
+  return [t, {
+    sendId: i
+  }, void 0];
+}
+function bn(e, t) {
+  e.defer(() => {
+    e.system.scheduler.cancel(e.self, t.sendId);
+  });
+}
+function kt(e) {
+  function t(n, s) {
+  }
+  return t.type = "xstate.cancel", t.sendId = e, t.resolve = Sn, t.execute = bn, t;
+}
+function wn(e, t, n, s, {
+  id: r,
+  systemId: i,
+  src: o,
+  input: a,
+  syncSnapshot: d
+}) {
+  const h = typeof o == "string" ? De(t.machine, o) : o, y = typeof r == "function" ? r(n) : r;
+  let u, c;
+  return h && (c = typeof a == "function" ? a({
+    context: t.context,
+    event: n.event,
+    self: e.self
+  }) : a, u = $(h, {
+    id: y,
+    src: o,
+    parent: e.self,
+    syncSnapshot: d,
+    systemId: i,
+    input: c
+  })), [D(t, {
+    children: {
+      ...t.children,
+      [y]: u
+    }
+  }), {
+    id: r,
+    systemId: i,
+    actorRef: u,
+    src: o,
+    input: c
+  }, void 0];
+}
+function En(e, {
+  actorRef: t
+}) {
+  t && e.defer(() => {
+    t._processingStatus !== E.Stopped && t.start();
+  });
+}
+function It(...[e, {
+  id: t,
+  systemId: n,
+  input: s,
+  syncSnapshot: r = !1
+} = {}]) {
+  function i(o, a) {
+  }
+  return i.type = "xstate.spawnChild", i.id = t, i.systemId = n, i.src = e, i.input = s, i.syncSnapshot = r, i.resolve = wn, i.execute = En, i;
+}
+function Tn(e, t, n, s, {
+  actorRef: r
+}) {
+  const i = typeof r == "function" ? r(n, s) : r, o = typeof i == "string" ? t.children[i] : i;
+  let a = t.children;
+  return o && (a = {
+    ...a
+  }, delete a[o.id]), [D(t, {
+    children: a
+  }), o, void 0];
+}
+function xn(e, t) {
+  if (t) {
+    if (e.system._unregister(t), t._processingStatus !== E.Running) {
+      e.stopChild(t);
+      return;
+    }
+    e.defer(() => {
+      e.stopChild(t);
+    });
+  }
+}
+function F(e) {
+  function t(n, s) {
+  }
+  return t.type = "xstate.stopChild", t.actorRef = e, t.resolve = Tn, t.execute = xn, t;
+}
+function kn(e, t, {
+  stateValue: n
+}) {
+  if (typeof n == "string" && ee(n)) {
+    const s = e.machine.getStateNodeById(n);
+    return e._nodes.some((r) => r === s);
+  }
+  return e.matches(n);
+}
+function Ns(e) {
+  function t() {
+    return !1;
+  }
+  return t.check = kn, t.stateValue = e, t;
+}
+function In(e, {
+  context: t,
+  event: n
+}, {
+  guards: s
+}) {
+  return !N(s[0], t, n, e);
+}
+function Xs(e) {
+  function t(n, s) {
+    return !1;
+  }
+  return t.check = In, t.guards = [e], t;
+}
+function An(e, {
+  context: t,
+  event: n
+}, {
+  guards: s
+}) {
+  return s.every((r) => N(r, t, n, e));
+}
+function Ys(e) {
+  function t(n, s) {
+    return !1;
+  }
+  return t.check = An, t.guards = e, t;
+}
+function N(e, t, n, s) {
+  const {
+    machine: r
+  } = s, i = typeof e == "function", o = i ? e : r.implementations.guards[typeof e == "string" ? e : e.type];
+  if (!i && !o)
+    throw new Error(`Guard '${typeof e == "string" ? e : e.type}' is not implemented.'.`);
+  if (typeof o != "function")
+    return N(o, t, n, s);
+  const a = {
+    context: t,
+    event: n
+  }, d = i || typeof e == "string" ? void 0 : "params" in e ? typeof e.params == "function" ? e.params({
+    context: t,
+    event: n
+  }) : e.params : void 0;
+  return "check" in o ? o.check(
+    s,
+    a,
+    o
+    // this holds all params
+  ) : o(a, d);
+}
+const He = (e) => e.type === "atomic" || e.type === "final";
+function z(e) {
+  return Object.values(e.states).filter((t) => t.type !== "history");
+}
+function Q(e, t) {
+  const n = [];
+  if (t === e)
+    return n;
+  let s = e.parent;
+  for (; s && s !== t; )
+    n.push(s), s = s.parent;
+  return n;
+}
+function ce(e) {
+  const t = new Set(e), n = Ct(t);
+  for (const s of t)
+    if (s.type === "compound" && (!n.get(s) || !n.get(s).length))
+      Qe(s).forEach((r) => t.add(r));
+    else if (s.type === "parallel") {
+      for (const r of z(s))
+        if (r.type !== "history" && !t.has(r)) {
+          const i = Qe(r);
+          for (const o of i)
+            t.add(o);
+        }
+    }
+  for (const s of t) {
+    let r = s.parent;
+    for (; r; )
+      t.add(r), r = r.parent;
+  }
+  return t;
+}
+function At(e, t) {
+  const n = t.get(e);
+  if (!n)
+    return {};
+  if (e.type === "compound") {
+    const r = n[0];
+    if (r) {
+      if (He(r))
+        return r.key;
+    } else
+      return {};
+  }
+  const s = {};
+  for (const r of n)
+    s[r.key] = At(r, t);
+  return s;
+}
+function Ct(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e)
+    t.has(n) || t.set(n, []), n.parent && (t.has(n.parent) || t.set(n.parent, []), t.get(n.parent).push(n));
+  return t;
+}
+function Rt(e, t) {
+  const n = ce(t);
+  return At(e, Ct(n));
+}
+function Ue(e, t) {
+  return t.type === "compound" ? z(t).some((n) => n.type === "final" && e.has(n)) : t.type === "parallel" ? z(t).every((n) => Ue(e, n)) : t.type === "final";
+}
+const ee = (e) => e[0] === cn;
+function Cn(e, t) {
+  return e.transitions.get(t) || [...e.transitions.keys()].filter((s) => {
+    if (s === un)
+      return !0;
+    if (!s.endsWith(".*"))
+      return !1;
+    const r = s.split("."), i = t.split(".");
+    for (let o = 0; o < r.length; o++) {
+      const a = r[o], d = i[o];
+      if (a === "*")
+        return o === r.length - 1;
+      if (a !== d)
+        return !1;
+    }
+    return !0;
+  }).sort((s, r) => r.length - s.length).flatMap((s) => e.transitions.get(s));
+}
+function Rn(e) {
+  const t = e.config.after;
+  if (!t)
+    return [];
+  const n = (r) => {
+    const i = fn(r, e.id), o = i.type;
+    return e.entry.push(x(i, {
+      id: o,
+      delay: r
+    })), e.exit.push(kt(o)), o;
+  };
+  return Object.keys(t).flatMap((r) => {
+    const i = t[r], o = typeof i == "string" ? {
+      target: i
+    } : i, a = Number.isNaN(+r) ? r : +r, d = n(a);
+    return C(o).map((h) => ({
+      ...h,
+      event: d,
+      delay: a
+    }));
+  }).map((r) => {
+    const {
+      delay: i
+    } = r;
+    return {
+      ...q(e, r.event, r),
+      delay: i
+    };
+  });
+}
+function q(e, t, n) {
+  const s = xt(n.target), r = n.reenter ?? !1, i = Ln(e, s), o = {
+    ...n,
+    actions: C(n.actions),
+    guard: n.guard,
+    target: i,
+    source: e,
+    reenter: r,
+    eventType: t,
+    toJSON: () => ({
+      ...o,
+      source: `#${e.id}`,
+      target: i ? i.map((a) => `#${a.id}`) : void 0
+    })
+  };
+  return o;
+}
+function Mn(e) {
+  const t = /* @__PURE__ */ new Map();
+  if (e.config.on)
+    for (const n of Object.keys(e.config.on)) {
+      if (n === vt)
+        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+      const s = e.config.on[n];
+      t.set(n, U(s).map((r) => q(e, n, r)));
+    }
+  if (e.config.onDone) {
+    const n = `xstate.done.state.${e.id}`;
+    t.set(n, U(e.config.onDone).map((s) => q(e, n, s)));
+  }
+  for (const n of e.invoke) {
+    if (n.onDone) {
+      const s = `xstate.done.actor.${n.id}`;
+      t.set(s, U(n.onDone).map((r) => q(e, s, r)));
+    }
+    if (n.onError) {
+      const s = `xstate.error.actor.${n.id}`;
+      t.set(s, U(n.onError).map((r) => q(e, s, r)));
+    }
+    if (n.onSnapshot) {
+      const s = `xstate.snapshot.${n.id}`;
+      t.set(s, U(n.onSnapshot).map((r) => q(e, s, r)));
+    }
+  }
+  for (const n of e.after) {
+    let s = t.get(n.eventType);
+    s || (s = [], t.set(n.eventType, s)), s.push(n);
+  }
+  return t;
+}
+function $n(e, t) {
+  const n = typeof t == "string" ? e.states[t] : t ? e.states[t.target] : void 0;
+  if (!n && t)
+    throw new Error(
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-base-to-string
+      `Initial state node "${t}" not found on parent state node #${e.id}`
+    );
+  const s = {
+    source: e,
+    actions: !t || typeof t == "string" ? [] : C(t.actions),
+    eventType: null,
+    reenter: !1,
+    target: n ? [n] : [],
+    toJSON: () => ({
+      ...s,
+      source: `#${e.id}`,
+      target: n ? [`#${n.id}`] : []
+    })
+  };
+  return s;
+}
+function Ln(e, t) {
+  if (t !== void 0)
+    return t.map((n) => {
+      if (typeof n != "string")
+        return n;
+      if (ee(n))
+        return e.machine.getStateNodeById(n);
+      const s = n[0] === mt;
+      if (s && !e.parent)
+        return ue(e, n.slice(1));
+      const r = s ? e.key + n : n;
+      if (e.parent)
+        try {
+          return ue(e.parent, r);
+        } catch (i) {
+          throw new Error(`Invalid transition definition for state node '${e.id}':
+${i.message}`);
+        }
+      else
+        throw new Error(`Invalid target: "${n}" is not a valid target from the root node. Did you mean ".${n}"?`);
+    });
+}
+function Mt(e) {
+  const t = xt(e.config.target);
+  return t ? {
+    target: t.map((n) => typeof n == "string" ? ue(e.parent, n) : n)
+  } : e.parent.initial;
+}
+function O(e) {
+  return e.type === "history";
+}
+function Qe(e) {
+  const t = $t(e);
+  for (const n of t)
+    for (const s of Q(n, e))
+      t.add(s);
+  return t;
+}
+function $t(e) {
+  const t = /* @__PURE__ */ new Set();
+  function n(s) {
+    if (!t.has(s)) {
+      if (t.add(s), s.type === "compound")
+        n(s.initial.target[0]);
+      else if (s.type === "parallel")
+        for (const r of z(s))
+          n(r);
+    }
+  }
+  return n(e), t;
+}
+function G(e, t) {
+  if (ee(t))
+    return e.machine.getStateNodeById(t);
+  if (!e.states)
+    throw new Error(`Unable to retrieve child state '${t}' from '${e.id}'; no child states exist.`);
+  const n = e.states[t];
+  if (!n)
+    throw new Error(`Child state '${t}' does not exist on '${e.id}'`);
+  return n;
+}
+function ue(e, t) {
+  if (typeof t == "string" && ee(t))
+    try {
+      return e.machine.getStateNodeById(t);
+    } catch {
+    }
+  const n = je(t).slice();
+  let s = e;
+  for (; n.length; ) {
+    const r = n.shift();
+    if (!r.length)
+      break;
+    s = G(s, r);
+  }
+  return s;
+}
+function de(e, t) {
+  if (typeof t == "string") {
+    const r = e.states[t];
+    if (!r)
+      throw new Error(`State '${t}' does not exist on '${e.id}'`);
+    return [e, r];
+  }
+  const n = Object.keys(t), s = n.map((r) => G(e, r)).filter(Boolean);
+  return [e.machine.root, e].concat(s, n.reduce((r, i) => {
+    const o = G(e, i);
+    if (!o)
+      return r;
+    const a = de(o, t[i]);
+    return r.concat(a);
+  }, []));
+}
+function qn(e, t, n, s) {
+  const i = G(e, t).next(n, s);
+  return !i || !i.length ? e.next(n, s) : i;
+}
+function On(e, t, n, s) {
+  const r = Object.keys(t), i = G(e, r[0]), o = We(i, t[r[0]], n, s);
+  return !o || !o.length ? e.next(n, s) : o;
+}
+function jn(e, t, n, s) {
+  const r = [];
+  for (const i of Object.keys(t)) {
+    const o = t[i];
+    if (!o)
+      continue;
+    const a = G(e, i), d = We(a, o, n, s);
+    d && r.push(...d);
+  }
+  return r.length ? r : e.next(n, s);
+}
+function We(e, t, n, s) {
+  return typeof t == "string" ? qn(e, t, n, s) : Object.keys(t).length === 1 ? On(e, t, n, s) : jn(e, t, n, s);
+}
+function Dn(e) {
+  return Object.keys(e.states).map((t) => e.states[t]).filter((t) => t.type === "history");
+}
+function L(e, t) {
+  let n = e;
+  for (; n.parent && n.parent !== t; )
+    n = n.parent;
+  return n.parent === t;
+}
+function Vn(e, t) {
+  const n = new Set(e), s = new Set(t);
+  for (const r of n)
+    if (s.has(r))
+      return !0;
+  for (const r of s)
+    if (n.has(r))
+      return !0;
+  return !1;
+}
+function Lt(e, t, n) {
+  const s = /* @__PURE__ */ new Set();
+  for (const r of e) {
+    let i = !1;
+    const o = /* @__PURE__ */ new Set();
+    for (const a of s)
+      if (Vn($e([r], t, n), $e([a], t, n)))
+        if (L(r.source, a.source))
+          o.add(a);
+        else {
+          i = !0;
+          break;
+        }
+    if (!i) {
+      for (const a of o)
+        s.delete(a);
+      s.add(r);
+    }
+  }
+  return Array.from(s);
+}
+function Hn(e) {
+  const [t, ...n] = e;
+  for (const s of Q(t, void 0))
+    if (n.every((r) => L(r, s)))
+      return s;
+}
+function Be(e, t) {
+  if (!e.target)
+    return [];
+  const n = /* @__PURE__ */ new Set();
+  for (const s of e.target)
+    if (O(s))
+      if (t[s.id])
+        for (const r of t[s.id])
+          n.add(r);
+      else
+        for (const r of Be(Mt(s), t))
+          n.add(r);
+    else
+      n.add(s);
+  return [...n];
+}
+function qt(e, t) {
+  const n = Be(e, t);
+  if (!n)
+    return;
+  if (!e.reenter && n.every((r) => r === e.source || L(r, e.source)))
+    return e.source;
+  const s = Hn(n.concat(e.source));
+  if (s)
+    return s;
+  if (!e.reenter)
+    return e.source.machine.root;
+}
+function $e(e, t, n) {
+  var r;
+  const s = /* @__PURE__ */ new Set();
+  for (const i of e)
+    if ((r = i.target) != null && r.length) {
+      const o = qt(i, n);
+      i.reenter && i.source === o && s.add(o);
+      for (const a of t)
+        L(a, o) && s.add(a);
+    }
+  return [...s];
+}
+function Un(e, t) {
+  if (e.length !== t.size)
+    return !1;
+  for (const n of e)
+    if (!t.has(n))
+      return !1;
+  return !0;
+}
+function Le(e, t, n, s, r, i) {
+  if (!e.length)
+    return t;
+  const o = new Set(t._nodes);
+  let a = t.historyValue;
+  const d = Lt(e, o, a);
+  let h = t;
+  r || ([h, a] = zn(h, s, n, d, o, a, i, n.actionExecutor)), h = J(h, s, n, d.flatMap((u) => u.actions), i, void 0), h = Bn(h, s, n, d, o, i, a, r);
+  const y = [...o];
+  h.status === "done" && (h = J(h, s, n, y.sort((u, c) => c.order - u.order).flatMap((u) => u.exit), i, void 0));
+  try {
+    return a === t.historyValue && Un(t._nodes, o) ? h : D(h, {
+      _nodes: y,
+      historyValue: a
+    });
+  } catch (u) {
+    throw u;
+  }
+}
+function Wn(e, t, n, s, r) {
+  if (s.output === void 0)
+    return;
+  const i = Re(r.id, r.output !== void 0 && r.parent ? Me(r.output, e.context, t, n.self) : void 0);
+  return Me(s.output, e.context, i, n.self);
+}
+function Bn(e, t, n, s, r, i, o, a) {
+  let d = e;
+  const h = /* @__PURE__ */ new Set(), y = /* @__PURE__ */ new Set();
+  Pn(s, o, y, h), a && y.add(e.machine.root);
+  const u = /* @__PURE__ */ new Set();
+  for (const c of [...h].sort((l, f) => l.order - f.order)) {
+    r.add(c);
+    const l = [];
+    l.push(...c.entry);
+    for (const f of c.invoke)
+      l.push(It(f.src, {
+        ...f,
+        syncSnapshot: !!f.onSnapshot
+      }));
+    if (y.has(c)) {
+      const f = c.initial.actions;
+      l.push(...f);
+    }
+    if (d = J(d, t, n, l, i, c.invoke.map((f) => f.id)), c.type === "final") {
+      const f = c.parent;
+      let p = (f == null ? void 0 : f.type) === "parallel" ? f : f == null ? void 0 : f.parent, g = p || c;
+      for ((f == null ? void 0 : f.type) === "compound" && i.push(Re(f.id, c.output !== void 0 ? Me(c.output, d.context, t, n.self) : void 0)); (p == null ? void 0 : p.type) === "parallel" && !u.has(p) && Ue(r, p); )
+        u.add(p), i.push(Re(p.id)), g = p, p = p.parent;
+      if (p)
+        continue;
+      d = D(d, {
+        status: "done",
+        output: Wn(d, t, n, d.machine.root, g)
+      });
+    }
+  }
+  return d;
+}
+function Pn(e, t, n, s) {
+  for (const r of e) {
+    const i = qt(r, t);
+    for (const a of r.target || [])
+      !O(a) && // if the target is different than the source then it will *definitely* be entered
+      (r.source !== a || // we know that the domain can't lie within the source
+      // if it's different than the source then it's outside of it and it means that the target has to be entered as well
+      r.source !== i || // reentering transitions always enter the target, even if it's the source itself
+      r.reenter) && (s.add(a), n.add(a)), W(a, t, n, s);
+    const o = Be(r, t);
+    for (const a of o) {
+      const d = Q(a, i);
+      (i == null ? void 0 : i.type) === "parallel" && d.push(i), Ot(s, t, n, d, !r.source.parent && r.reenter ? void 0 : i);
+    }
+  }
+}
+function W(e, t, n, s) {
+  var r;
+  if (O(e))
+    if (t[e.id]) {
+      const i = t[e.id];
+      for (const o of i)
+        s.add(o), W(o, t, n, s);
+      for (const o of i)
+        ve(o, e.parent, s, t, n);
+    } else {
+      const i = Mt(e);
+      for (const o of i.target)
+        s.add(o), i === ((r = e.parent) == null ? void 0 : r.initial) && n.add(e.parent), W(o, t, n, s);
+      for (const o of i.target)
+        ve(o, e.parent, s, t, n);
+    }
+  else if (e.type === "compound") {
+    const [i] = e.initial.target;
+    O(i) || (s.add(i), n.add(i)), W(i, t, n, s), ve(i, e, s, t, n);
+  } else if (e.type === "parallel")
+    for (const i of z(e).filter((o) => !O(o)))
+      [...s].some((o) => L(o, i)) || (O(i) || (s.add(i), n.add(i)), W(i, t, n, s));
+}
+function Ot(e, t, n, s, r) {
+  for (const i of s)
+    if ((!r || L(i, r)) && e.add(i), i.type === "parallel")
+      for (const o of z(i).filter((a) => !O(a)))
+        [...e].some((a) => L(a, o)) || (e.add(o), W(o, t, n, e));
+}
+function ve(e, t, n, s, r) {
+  Ot(n, s, r, Q(e, t));
+}
+function zn(e, t, n, s, r, i, o, a) {
+  let d = e;
+  const h = $e(s, r, i);
+  h.sort((u, c) => c.order - u.order);
+  let y;
+  for (const u of h)
+    for (const c of Dn(u)) {
+      let l;
+      c.history === "deep" ? l = (f) => He(f) && L(f, u) : l = (f) => f.parent === u, y ?? (y = {
+        ...i
+      }), y[c.id] = Array.from(r).filter(l);
+    }
+  for (const u of h)
+    d = J(d, t, n, [...u.exit, ...u.invoke.map((c) => F(c.id))], o, void 0), r.delete(u);
+  return [d, y || i];
+}
+function Gn(e, t) {
+  return e.implementations.actions[t];
+}
+function jt(e, t, n, s, r, i) {
+  const {
+    machine: o
+  } = e;
+  let a = e;
+  for (const d of s) {
+    const h = typeof d == "function", y = h ? d : (
+      // the existing type of `.actions` assumes non-nullable `TExpressionAction`
+      // it's fine to cast this here to get a common type and lack of errors in the rest of the code
+      // our logic below makes sure that we call those 2 "variants" correctly
+      Gn(o, typeof d == "string" ? d : d.type)
+    ), u = {
+      context: a.context,
+      event: t,
+      self: n.self,
+      system: n.system
+    }, c = h || typeof d == "string" ? void 0 : "params" in d ? typeof d.params == "function" ? d.params({
+      context: a.context,
+      event: t
+    }) : d.params : void 0;
+    if (!y || !("resolve" in y)) {
+      n.actionExecutor({
+        type: typeof d == "string" ? d : typeof d == "object" ? d.type : d.name || "(anonymous)",
+        info: u,
+        params: c,
+        exec: y
+      });
+      continue;
+    }
+    const l = y, [f, p, g] = l.resolve(
+      n,
+      a,
+      u,
+      c,
+      y,
+      // this holds all params
+      r
+    );
+    a = f, "retryResolve" in l && (i == null || i.push([l, p])), "execute" in l && n.actionExecutor({
+      type: l.type,
+      info: u,
+      params: p,
+      exec: l.execute.bind(null, n, p)
+    }), g && (a = jt(a, t, n, g, r, i));
+  }
+  return a;
+}
+function J(e, t, n, s, r, i) {
+  const o = i ? [] : void 0, a = jt(e, t, n, s, {
+    internalQueue: r,
+    deferredActorIds: i
+  }, o);
+  return o == null || o.forEach(([d, h]) => {
+    d.retryResolve(n, a, h);
+  }), a;
+}
+function _e(e, t, n, s) {
+  let r = e;
+  const i = [];
+  function o(h, y, u) {
+    n.system._sendInspectionEvent({
+      type: "@xstate.microstep",
+      actorRef: n.self,
+      event: y,
+      snapshot: h,
+      _transitions: u
+    }), i.push(h);
+  }
+  if (t.type === j)
+    return r = D(et(r, t, n), {
+      status: "stopped"
+    }), o(r, t, []), {
+      snapshot: r,
+      microstates: i
+    };
+  let a = t;
+  if (a.type !== _t) {
+    const h = a, y = yn(h), u = tt(h, r);
+    if (y && !u.length)
+      return r = D(e, {
+        status: "error",
+        error: h.error
+      }), o(r, h, []), {
+        snapshot: r,
+        microstates: i
+      };
+    r = Le(
+      u,
+      e,
+      n,
+      a,
+      !1,
+      // isInitial
+      s
+    ), o(r, h, u);
+  }
+  let d = !0;
+  for (; r.status === "active"; ) {
+    let h = d ? Jn(r, a) : [];
+    const y = h.length ? r : void 0;
+    if (!h.length) {
+      if (!s.length)
+        break;
+      a = s.shift(), h = tt(a, r);
+    }
+    r = Le(h, r, n, a, !1, s), d = r !== y, o(r, a, h);
+  }
+  return r.status !== "active" && et(r, a, n), {
+    snapshot: r,
+    microstates: i
+  };
+}
+function et(e, t, n) {
+  return J(e, t, n, Object.values(e.children).map((s) => F(s)), [], void 0);
+}
+function tt(e, t) {
+  return t.machine.getTransitionData(t, e);
+}
+function Jn(e, t) {
+  const n = /* @__PURE__ */ new Set(), s = e._nodes.filter(He);
+  for (const r of s)
+    e: for (const i of [r].concat(Q(r, void 0)))
+      if (i.always) {
+        for (const o of i.always)
+          if (o.guard === void 0 || N(o.guard, e.context, t, e)) {
+            n.add(o);
+            break e;
+          }
+      }
+  return Lt(Array.from(n), new Set(e._nodes), e.historyValue);
+}
+function Nn(e, t) {
+  const n = ce(de(e, t));
+  return Rt(e, [...n]);
+}
+function Xn(e) {
+  return !!e && typeof e == "object" && "machine" in e && "value" in e;
+}
+const Yn = function(t) {
+  return wt(t, this.value);
+}, Kn = function(t) {
+  return this.tags.has(t);
+}, Zn = function(t) {
+  const n = this.machine.getTransitionData(this, t);
+  return !!(n != null && n.length) && // Check that at least one transition is not forbidden
+  n.some((s) => s.target !== void 0 || s.actions.length);
+}, Fn = function() {
+  const {
+    _nodes: t,
+    tags: n,
+    machine: s,
+    getMeta: r,
+    toJSON: i,
+    can: o,
+    hasTag: a,
+    matches: d,
+    ...h
+  } = this;
+  return {
+    ...h,
+    tags: Array.from(n)
+  };
+}, Qn = function() {
+  return this._nodes.reduce((t, n) => (n.meta !== void 0 && (t[n.id] = n.meta), t), {});
+};
+function se(e, t) {
+  return {
+    status: e.status,
+    output: e.output,
+    error: e.error,
+    machine: t,
+    context: e.context,
+    _nodes: e._nodes,
+    value: Rt(t.root, e._nodes),
+    tags: new Set(e._nodes.flatMap((n) => n.tags)),
+    children: e.children,
+    historyValue: e.historyValue || {},
+    matches: Yn,
+    hasTag: Kn,
+    can: Zn,
+    getMeta: Qn,
+    toJSON: Fn
+  };
+}
+function D(e, t = {}) {
+  return se({
+    ...e,
+    ...t
+  }, e.machine);
+}
+function es(e) {
+  if (typeof e != "object" || e === null)
+    return {};
+  const t = {};
+  for (const n in e) {
+    const s = e[n];
+    Array.isArray(s) && (t[n] = s.map((r) => ({
+      id: r.id
+    })));
+  }
+  return t;
+}
+function ts(e, t) {
+  const {
+    _nodes: n,
+    tags: s,
+    machine: r,
+    children: i,
+    context: o,
+    can: a,
+    hasTag: d,
+    matches: h,
+    getMeta: y,
+    toJSON: u,
+    ...c
+  } = e, l = {};
+  for (const p in i) {
+    const g = i[p];
+    l[p] = {
+      snapshot: g.getPersistedSnapshot(t),
+      src: g.src,
+      systemId: g._systemId,
+      syncSnapshot: g._syncSnapshot
+    };
+  }
+  return {
+    ...c,
+    context: Dt(o),
+    children: l,
+    historyValue: es(c.historyValue)
+  };
+}
+function Dt(e) {
+  let t;
+  for (const n in e) {
+    const s = e[n];
+    if (s && typeof s == "object")
+      if ("sessionId" in s && "send" in s && "ref" in s)
+        t ?? (t = Array.isArray(e) ? e.slice() : {
+          ...e
+        }), t[n] = {
+          xstate$$type: Ve,
+          id: s.id
+        };
+      else {
+        const r = Dt(s);
+        r !== s && (t ?? (t = Array.isArray(e) ? e.slice() : {
+          ...e
+        }), t[n] = r);
+      }
+  }
+  return t ?? e;
+}
+function ns(e, t, n, s, {
+  event: r,
+  id: i,
+  delay: o
+}, {
+  internalQueue: a
+}) {
+  const d = t.machine.implementations.delays;
+  if (typeof r == "string")
+    throw new Error(
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Only event objects may be used with raise; use raise({ type: "${r}" }) instead`
+    );
+  const h = typeof r == "function" ? r(n, s) : r;
+  let y;
+  if (typeof o == "string") {
+    const u = d && d[o];
+    y = typeof u == "function" ? u(n, s) : u;
+  } else
+    y = typeof o == "function" ? o(n, s) : o;
+  return typeof y != "number" && a.push(h), [t, {
+    event: h,
+    id: i,
+    delay: y
+  }, void 0];
+}
+function ss(e, t) {
+  const {
+    event: n,
+    delay: s,
+    id: r
+  } = t;
+  if (typeof s == "number") {
+    e.defer(() => {
+      const i = e.self;
+      e.system.scheduler.schedule(i, i, n, s, r);
+    });
+    return;
+  }
+}
+function x(e, t) {
+  function n(s, r) {
+  }
+  return n.type = "xstate.raise", n.event = e, n.id = t == null ? void 0 : t.id, n.delay = t == null ? void 0 : t.delay, n.resolve = ns, n.execute = ss, n;
+}
+const nt = /* @__PURE__ */ new WeakMap();
+function rs(e) {
+  return {
+    config: e,
+    start: (n, s) => {
+      const {
+        self: r,
+        system: i,
+        emit: o
+      } = s, a = {
+        receivers: void 0,
+        dispose: void 0
+      };
+      nt.set(r, a), a.dispose = e({
+        input: n.input,
+        system: i,
+        self: r,
+        sendBack: (d) => {
+          r.getSnapshot().status !== "stopped" && r._parent && i._relay(r, r._parent, d);
+        },
+        receive: (d) => {
+          a.receivers ?? (a.receivers = /* @__PURE__ */ new Set()), a.receivers.add(d);
+        },
+        emit: o
+      });
+    },
+    transition: (n, s, r) => {
+      var o, a;
+      const i = nt.get(r.self);
+      return s.type === j ? (n = {
+        ...n,
+        status: "stopped",
+        error: void 0
+      }, (o = i.dispose) == null || o.call(i), n) : ((a = i.receivers) == null || a.forEach((d) => d(s)), n);
+    },
+    getInitialSnapshot: (n, s) => ({
+      status: "active",
+      output: void 0,
+      error: void 0,
+      input: s
+    }),
+    getPersistedSnapshot: (n) => n,
+    restoreSnapshot: (n) => n
+  };
+}
+const st = "xstate.observable.next", fe = "xstate.observable.error", he = "xstate.observable.complete";
+function Ks(e) {
+  return {
+    config: e,
+    transition: (n, s) => {
+      if (n.status !== "active")
+        return n;
+      switch (s.type) {
+        case st:
+          return {
+            ...n,
+            context: s.data
+          };
+        case fe:
+          return {
+            ...n,
+            status: "error",
+            error: s.data,
+            input: void 0,
+            _subscription: void 0
+          };
+        case he:
+          return {
+            ...n,
+            status: "done",
+            input: void 0,
+            _subscription: void 0
+          };
+        case j:
+          return n._subscription.unsubscribe(), {
+            ...n,
+            status: "stopped",
+            input: void 0,
+            _subscription: void 0
+          };
+        default:
+          return n;
+      }
+    },
+    getInitialSnapshot: (n, s) => ({
+      status: "active",
+      output: void 0,
+      error: void 0,
+      context: void 0,
+      input: s,
+      _subscription: void 0
+    }),
+    start: (n, {
+      self: s,
+      system: r,
+      emit: i
+    }) => {
+      n.status !== "done" && (n._subscription = e({
+        input: n.input,
+        system: r,
+        self: s,
+        emit: i
+      }).subscribe({
+        next: (o) => {
+          r._relay(s, s, {
+            type: st,
+            data: o
+          });
+        },
+        error: (o) => {
+          r._relay(s, s, {
+            type: fe,
+            data: o
+          });
+        },
+        complete: () => {
+          r._relay(s, s, {
+            type: he
+          });
+        }
+      }));
+    },
+    getPersistedSnapshot: ({
+      _subscription: n,
+      ...s
+    }) => s,
+    restoreSnapshot: (n) => ({
+      ...n,
+      _subscription: void 0
+    })
+  };
+}
+function Vt(e) {
+  return {
+    config: e,
+    transition: (n, s) => {
+      if (n.status !== "active")
+        return n;
+      switch (s.type) {
+        case fe:
+          return {
+            ...n,
+            status: "error",
+            error: s.data,
+            input: void 0,
+            _subscription: void 0
+          };
+        case he:
+          return {
+            ...n,
+            status: "done",
+            input: void 0,
+            _subscription: void 0
+          };
+        case j:
+          return n._subscription.unsubscribe(), {
+            ...n,
+            status: "stopped",
+            input: void 0,
+            _subscription: void 0
+          };
+        default:
+          return n;
+      }
+    },
+    getInitialSnapshot: (n, s) => ({
+      status: "active",
+      output: void 0,
+      error: void 0,
+      context: void 0,
+      input: s,
+      _subscription: void 0
+    }),
+    start: (n, {
+      self: s,
+      system: r,
+      emit: i
+    }) => {
+      n.status !== "done" && (n._subscription = e({
+        input: n.input,
+        system: r,
+        self: s,
+        emit: i
+      }).subscribe({
+        next: (o) => {
+          s._parent && r._relay(s, s._parent, o);
+        },
+        error: (o) => {
+          r._relay(s, s, {
+            type: fe,
+            data: o
+          });
+        },
+        complete: () => {
+          r._relay(s, s, {
+            type: he
+          });
+        }
+      }));
+    },
+    getPersistedSnapshot: ({
+      _subscription: n,
+      ...s
+    }) => s,
+    restoreSnapshot: (n) => ({
+      ...n,
+      _subscription: void 0
+    })
+  };
+}
+const rt = "xstate.promise.resolve", it = "xstate.promise.reject", ne = /* @__PURE__ */ new WeakMap();
+function Zs(e) {
+  return {
+    config: e,
+    transition: (n, s, r) => {
+      var i;
+      if (n.status !== "active")
+        return n;
+      switch (s.type) {
+        case rt: {
+          const o = s.data;
+          return {
+            ...n,
+            status: "done",
+            output: o,
+            input: void 0
+          };
+        }
+        case it:
+          return {
+            ...n,
+            status: "error",
+            error: s.data,
+            input: void 0
+          };
+        case j:
+          return (i = ne.get(r.self)) == null || i.abort(), {
+            ...n,
+            status: "stopped",
+            input: void 0
+          };
+        default:
+          return n;
+      }
+    },
+    start: (n, {
+      self: s,
+      system: r,
+      emit: i
+    }) => {
+      if (n.status !== "active")
+        return;
+      const o = new AbortController();
+      ne.set(s, o), Promise.resolve(e({
+        input: n.input,
+        system: r,
+        self: s,
+        signal: o.signal,
+        emit: i
+      })).then((d) => {
+        s.getSnapshot().status === "active" && (ne.delete(s), r._relay(s, s, {
+          type: rt,
+          data: d
+        }));
+      }, (d) => {
+        s.getSnapshot().status === "active" && (ne.delete(s), r._relay(s, s, {
+          type: it,
+          data: d
+        }));
+      });
+    },
+    getInitialSnapshot: (n, s) => ({
+      status: "active",
+      output: void 0,
+      error: void 0,
+      input: s
+    }),
+    getPersistedSnapshot: (n) => n,
+    restoreSnapshot: (n) => n
+  };
+}
+function is(e, {
+  machine: t,
+  context: n
+}, s, r) {
+  const i = (o, a) => {
+    if (typeof o == "string") {
+      const d = De(t, o);
+      if (!d)
+        throw new Error(`Actor logic '${o}' not implemented in machine '${t.id}'`);
+      const h = $(d, {
+        id: a == null ? void 0 : a.id,
+        parent: e.self,
+        syncSnapshot: a == null ? void 0 : a.syncSnapshot,
+        input: typeof (a == null ? void 0 : a.input) == "function" ? a.input({
+          context: n,
+          event: s,
+          self: e.self
+        }) : a == null ? void 0 : a.input,
+        src: o,
+        systemId: a == null ? void 0 : a.systemId
+      });
+      return r[h.id] = h, h;
+    } else
+      return $(o, {
+        id: a == null ? void 0 : a.id,
+        parent: e.self,
+        syncSnapshot: a == null ? void 0 : a.syncSnapshot,
+        input: a == null ? void 0 : a.input,
+        src: o,
+        systemId: a == null ? void 0 : a.systemId
+      });
+  };
+  return (o, a) => {
+    const d = i(o, a);
+    return r[d.id] = d, e.defer(() => {
+      d._processingStatus !== E.Stopped && d.start();
+    }), d;
+  };
+}
+function os(e, t, n, s, {
+  assignment: r
+}) {
+  if (!t.context)
+    throw new Error("Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.");
+  const i = {}, o = {
+    context: t.context,
+    event: n.event,
+    spawn: is(e, t, n.event, i),
+    self: e.self,
+    system: e.system
+  };
+  let a = {};
+  if (typeof r == "function")
+    a = r(o, s);
+  else
+    for (const h of Object.keys(r)) {
+      const y = r[h];
+      a[h] = typeof y == "function" ? y(o, s) : y;
+    }
+  const d = Object.assign({}, t.context, a);
+  return [D(t, {
+    context: d,
+    children: Object.keys(i).length ? {
+      ...t.children,
+      ...i
+    } : t.children
+  }), void 0, void 0];
+}
+function M(e) {
+  function t(n, s) {
+  }
+  return t.type = "xstate.assign", t.assignment = e, t.resolve = os, t;
+}
+const ot = /* @__PURE__ */ new WeakMap();
+function H(e, t, n) {
+  let s = ot.get(e);
+  return s ? t in s || (s[t] = n()) : (s = {
+    [t]: n()
+  }, ot.set(e, s)), s[t];
+}
+const as = {}, X = (e) => typeof e == "string" ? {
+  type: e
+} : typeof e == "function" ? "resolve" in e ? {
+  type: e.type
+} : {
+  type: e.name
+} : e;
+class le {
+  constructor(t, n) {
+    if (this.config = t, this.key = void 0, this.id = void 0, this.type = void 0, this.path = void 0, this.states = void 0, this.history = void 0, this.entry = void 0, this.exit = void 0, this.parent = void 0, this.machine = void 0, this.meta = void 0, this.output = void 0, this.order = -1, this.description = void 0, this.tags = [], this.transitions = void 0, this.always = void 0, this.parent = n._parent, this.key = n._key, this.machine = n._machine, this.path = this.parent ? this.parent.path.concat(this.key) : [], this.id = this.config.id || [this.machine.id, ...this.path].join(mt), this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? "compound" : this.config.history ? "history" : "atomic"), this.description = this.config.description, this.order = this.machine.idMap.size, this.machine.idMap.set(this.id, this), this.states = this.config.states ? Ke(this.config.states, (s, r) => new le(s, {
+      _parent: this,
+      _key: r,
+      _machine: this.machine
+    })) : as, this.type === "compound" && !this.config.initial)
+      throw new Error(`No initial state specified for compound state node "#${this.id}". Try adding { initial: "${Object.keys(this.states)[0]}" } to the state config.`);
+    this.history = this.config.history === !0 ? "shallow" : this.config.history || !1, this.entry = C(this.config.entry).slice(), this.exit = C(this.config.exit).slice(), this.meta = this.config.meta, this.output = this.type === "final" || !this.parent ? this.config.output : void 0, this.tags = C(t.tags).slice();
+  }
+  /** @internal */
+  _initialize() {
+    this.transitions = Mn(this), this.config.always && (this.always = U(this.config.always).map((t) => q(this, vt, t))), Object.keys(this.states).forEach((t) => {
+      this.states[t]._initialize();
+    });
+  }
+  /** The well-structured state node definition. */
+  get definition() {
+    return {
+      id: this.id,
+      key: this.key,
+      version: this.machine.version,
+      type: this.type,
+      initial: this.initial ? {
+        target: this.initial.target,
+        source: this,
+        actions: this.initial.actions.map(X),
+        eventType: null,
+        reenter: !1,
+        toJSON: () => ({
+          target: this.initial.target.map((t) => `#${t.id}`),
+          source: `#${this.id}`,
+          actions: this.initial.actions.map(X),
+          eventType: null
+        })
+      } : void 0,
+      history: this.history,
+      states: Ke(this.states, (t) => t.definition),
+      on: this.on,
+      transitions: [...this.transitions.values()].flat().map((t) => ({
+        ...t,
+        actions: t.actions.map(X)
+      })),
+      entry: this.entry.map(X),
+      exit: this.exit.map(X),
+      meta: this.meta,
+      order: this.order || -1,
+      output: this.output,
+      invoke: this.invoke,
+      description: this.description,
+      tags: this.tags
+    };
+  }
+  /** @internal */
+  toJSON() {
+    return this.definition;
+  }
+  /** The logic invoked as actors by this state node. */
+  get invoke() {
+    return H(this, "invoke", () => C(this.config.invoke).map((t, n) => {
+      const {
+        src: s,
+        systemId: r
+      } = t, i = t.id ?? Ze(this.id, n), o = typeof s == "string" ? s : `xstate.invoke.${Ze(this.id, n)}`;
+      return {
+        ...t,
+        src: o,
+        id: i,
+        systemId: r,
+        toJSON() {
+          const {
+            onDone: a,
+            onError: d,
+            ...h
+          } = t;
+          return {
+            ...h,
+            type: "xstate.invoke",
+            src: o,
+            id: i
+          };
+        }
+      };
+    }));
+  }
+  /** The mapping of events to transitions. */
+  get on() {
+    return H(this, "on", () => [...this.transitions].flatMap(([n, s]) => s.map((r) => [n, r])).reduce((n, [s, r]) => (n[s] = n[s] || [], n[s].push(r), n), {}));
+  }
+  get after() {
+    return H(this, "delayedTransitions", () => Rn(this));
+  }
+  get initial() {
+    return H(this, "initial", () => $n(this, this.config.initial));
+  }
+  /** @internal */
+  next(t, n) {
+    const s = n.type, r = [];
+    let i;
+    const o = H(this, `candidates-${s}`, () => Cn(this, s));
+    for (const a of o) {
+      const {
+        guard: d
+      } = a, h = t.context;
+      let y = !1;
+      try {
+        y = !d || N(d, h, n, t);
+      } catch (u) {
+        const c = typeof d == "string" ? d : typeof d == "object" ? d.type : void 0;
+        throw new Error(`Unable to evaluate guard ${c ? `'${c}' ` : ""}in transition for event '${s}' in state node '${this.id}':
+${u.message}`);
+      }
+      if (y) {
+        r.push(...a.actions), i = a;
+        break;
+      }
+    }
+    return i ? [i] : void 0;
+  }
+  /** All the event types accepted by this state node and its descendants. */
+  get events() {
+    return H(this, "events", () => {
+      const {
+        states: t
+      } = this, n = new Set(this.ownEvents);
+      if (t)
+        for (const s of Object.keys(t)) {
+          const r = t[s];
+          if (r.states)
+            for (const i of r.events)
+              n.add(`${i}`);
+        }
+      return Array.from(n);
+    });
+  }
+  /**
+   * All the events that have transitions directly from this state node.
+   *
+   * Excludes any inert events.
+   */
+  get ownEvents() {
+    const t = new Set([...this.transitions.keys()].filter((n) => this.transitions.get(n).some((s) => !(!s.target && !s.actions.length && !s.reenter))));
+    return Array.from(t);
+  }
+}
+const cs = "#";
+class Pe {
+  constructor(t, n) {
+    this.config = t, this.version = void 0, this.schemas = void 0, this.implementations = void 0, this.__xstatenode = !0, this.idMap = /* @__PURE__ */ new Map(), this.root = void 0, this.id = void 0, this.states = void 0, this.events = void 0, this.id = t.id || "(machine)", this.implementations = {
+      actors: (n == null ? void 0 : n.actors) ?? {},
+      actions: (n == null ? void 0 : n.actions) ?? {},
+      delays: (n == null ? void 0 : n.delays) ?? {},
+      guards: (n == null ? void 0 : n.guards) ?? {}
+    }, this.version = this.config.version, this.schemas = this.config.schemas, this.transition = this.transition.bind(this), this.getInitialSnapshot = this.getInitialSnapshot.bind(this), this.getPersistedSnapshot = this.getPersistedSnapshot.bind(this), this.restoreSnapshot = this.restoreSnapshot.bind(this), this.start = this.start.bind(this), this.root = new le(t, {
+      _key: this.id,
+      _machine: this
+    }), this.root._initialize(), this.states = this.root.states, this.events = this.root.events;
+  }
+  /**
+   * Clones this state machine with the provided implementations.
+   *
+   * @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
+   *   recursively merge with the existing options.
+   * @returns A new `StateMachine` instance with the provided implementations.
+   */
+  provide(t) {
+    const {
+      actions: n,
+      guards: s,
+      actors: r,
+      delays: i
+    } = this.implementations;
+    return new Pe(this.config, {
+      actions: {
+        ...n,
+        ...t.actions
+      },
+      guards: {
+        ...s,
+        ...t.guards
+      },
+      actors: {
+        ...r,
+        ...t.actors
+      },
+      delays: {
+        ...i,
+        ...t.delays
+      }
+    });
+  }
+  resolveState(t) {
+    const n = Nn(this.root, t.value), s = ce(de(this.root, n));
+    return se({
+      _nodes: [...s],
+      context: t.context || {},
+      children: {},
+      status: Ue(s, this.root) ? "done" : t.status || "active",
+      output: t.output,
+      error: t.error,
+      historyValue: t.historyValue
+    }, this);
+  }
+  /**
+   * Determines the next snapshot given the current `snapshot` and received
+   * `event`. Calculates a full macrostep from all microsteps.
+   *
+   * @param snapshot The current snapshot
+   * @param event The received event
+   */
+  transition(t, n, s) {
+    return _e(t, n, s, []).snapshot;
+  }
+  /**
+   * Determines the next state given the current `state` and `event`. Calculates
+   * a microstep.
+   *
+   * @param state The current state
+   * @param event The received event
+   */
+  microstep(t, n, s) {
+    return _e(t, n, s, []).microstates;
+  }
+  getTransitionData(t, n) {
+    return We(this.root, t.value, t, n) || [];
+  }
+  /**
+   * The initial state _before_ evaluating any microsteps. This "pre-initial"
+   * state is provided to initial actions executed in the initial state.
+   */
+  getPreInitialState(t, n, s) {
+    const {
+      context: r
+    } = this.config, i = se({
+      context: typeof r != "function" && r ? r : {},
+      _nodes: [this.root],
+      children: {},
+      status: "active"
+    }, this);
+    return typeof r == "function" ? J(i, n, t, [M(({
+      spawn: a,
+      event: d,
+      self: h
+    }) => r({
+      spawn: a,
+      input: d.input,
+      self: h
+    }))], s, void 0) : i;
+  }
+  /**
+   * Returns the initial `State` instance, with reference to `self` as an
+   * `ActorRef`.
+   */
+  getInitialSnapshot(t, n) {
+    const s = bt(n), r = [], i = this.getPreInitialState(t, s, r), o = Le([{
+      target: [...$t(this.root)],
+      source: this.root,
+      reenter: !0,
+      actions: [],
+      eventType: null,
+      toJSON: null
+      // TODO: fix
+    }], i, t, s, !0, r), {
+      snapshot: a
+    } = _e(o, s, t, r);
+    return a;
+  }
+  start(t) {
+    Object.values(t.children).forEach((n) => {
+      n.getSnapshot().status === "active" && n.start();
+    });
+  }
+  getStateNodeById(t) {
+    const n = je(t), s = n.slice(1), r = ee(n[0]) ? n[0].slice(cs.length) : n[0], i = this.idMap.get(r);
+    if (!i)
+      throw new Error(`Child state node '#${r}' does not exist on machine '${this.id}'`);
+    return ue(i, s);
+  }
+  get definition() {
+    return this.root.definition;
+  }
+  toJSON() {
+    return this.definition;
+  }
+  getPersistedSnapshot(t, n) {
+    return ts(t, n);
+  }
+  restoreSnapshot(t, n) {
+    const s = {}, r = t.children;
+    Object.keys(r).forEach((u) => {
+      const c = r[u], l = c.snapshot, f = c.src, p = typeof f == "string" ? De(this, f) : f;
+      if (!p)
+        return;
+      const g = $(p, {
+        id: u,
+        parent: n.self,
+        syncSnapshot: c.syncSnapshot,
+        snapshot: l,
+        src: f,
+        systemId: c.systemId
+      });
+      s[u] = g;
+    });
+    function i(u, c) {
+      if (c instanceof le)
+        return c;
+      try {
+        return u.machine.getStateNodeById(c.id);
+      } catch {
+      }
+    }
+    function o(u, c) {
+      if (!c || typeof c != "object")
+        return {};
+      const l = {};
+      for (const f in c) {
+        const p = c[f];
+        for (const g of p) {
+          const m = i(u, g);
+          m && (l[f] ?? (l[f] = []), l[f].push(m));
+        }
+      }
+      return l;
+    }
+    const a = o(this.root, t.historyValue), d = se({
+      ...t,
+      children: s,
+      _nodes: Array.from(ce(de(this.root, t.value))),
+      historyValue: a
+    }, this), h = /* @__PURE__ */ new Set();
+    function y(u, c) {
+      if (!h.has(u)) {
+        h.add(u);
+        for (const l in u) {
+          const f = u[l];
+          if (f && typeof f == "object") {
+            if ("xstate$$type" in f && f.xstate$$type === Ve) {
+              u[l] = c[f.id];
+              continue;
+            }
+            y(f, c);
+          }
+        }
+      }
+    }
+    return y(d.context, s), d;
+  }
+}
+function us(e, t, n, s, {
+  event: r
+}) {
+  const i = typeof r == "function" ? r(n, s) : r;
+  return [t, {
+    event: i
+  }, void 0];
+}
+function ds(e, {
+  event: t
+}) {
+  e.defer(() => e.emit(t));
+}
+function pe(e) {
+  function t(n, s) {
+  }
+  return t.type = "xstate.emit", t.event = e, t.resolve = us, t.execute = ds, t;
+}
+let qe = /* @__PURE__ */ function(e) {
+  return e.Parent = "#_parent", e.Internal = "#_internal", e;
+}({});
+function fs(e, t, n, s, {
+  to: r,
+  event: i,
+  id: o,
+  delay: a
+}, d) {
+  var f;
+  const h = t.machine.implementations.delays;
+  if (typeof i == "string")
+    throw new Error(
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Only event objects may be used with sendTo; use sendTo({ type: "${i}" }) instead`
+    );
+  const y = typeof i == "function" ? i(n, s) : i;
+  let u;
+  if (typeof a == "string") {
+    const p = h && h[a];
+    u = typeof p == "function" ? p(n, s) : p;
+  } else
+    u = typeof a == "function" ? a(n, s) : a;
+  const c = typeof r == "function" ? r(n, s) : r;
+  let l;
+  if (typeof c == "string") {
+    if (c === qe.Parent ? l = e.self._parent : c === qe.Internal ? l = e.self : c.startsWith("#_") ? l = t.children[c.slice(2)] : l = (f = d.deferredActorIds) != null && f.includes(c) ? c : t.children[c], !l)
+      throw new Error(`Unable to send event to actor '${c}' from machine '${t.machine.id}'.`);
+  } else
+    l = c || e.self;
+  return [t, {
+    to: l,
+    targetId: typeof c == "string" ? c : void 0,
+    event: y,
+    id: o,
+    delay: u
+  }, void 0];
+}
+function hs(e, t, n) {
+  typeof n.to == "string" && (n.to = t.children[n.to]);
+}
+function ls(e, t) {
+  e.defer(() => {
+    const {
+      to: n,
+      event: s,
+      delay: r,
+      id: i
+    } = t;
+    if (typeof r == "number") {
+      e.system.scheduler.schedule(e.self, n, s, r, i);
+      return;
+    }
+    e.system._relay(
+      e.self,
+      // at this point, in a deferred task, it should already be mutated by retryResolveSendTo
+      // if it initially started as a string
+      n,
+      s.type === dn ? St(e.self.id, s.data) : s
+    );
+  });
+}
+function K(e, t, n) {
+  function s(r, i) {
+  }
+  return s.type = "xstate.sendTo", s.to = e, s.event = t, s.id = n == null ? void 0 : n.id, s.delay = n == null ? void 0 : n.delay, s.resolve = fs, s.retryResolve = hs, s.execute = ls, s;
+}
+function ps(e, t) {
+  return K(qe.Parent, e, t);
+}
+function ys(e, t, n, s, {
+  collect: r
+}) {
+  const i = [], o = function(d) {
+    i.push(d);
+  };
+  return o.assign = (...a) => {
+    i.push(M(...a));
+  }, o.cancel = (...a) => {
+    i.push(kt(...a));
+  }, o.raise = (...a) => {
+    i.push(x(...a));
+  }, o.sendTo = (...a) => {
+    i.push(K(...a));
+  }, o.sendParent = (...a) => {
+    i.push(ps(...a));
+  }, o.spawnChild = (...a) => {
+    i.push(It(...a));
+  }, o.stopChild = (...a) => {
+    i.push(F(...a));
+  }, o.emit = (...a) => {
+    i.push(pe(...a));
+  }, r({
+    context: n.context,
+    event: n.event,
+    enqueue: o,
+    check: (a) => N(a, t.context, n.event, t),
+    self: e.self,
+    system: e.system
+  }, s), [t, void 0, i];
+}
+function A(e) {
+  function t(n, s) {
+  }
+  return t.type = "xstate.enqueueActions", t.collect = e, t.resolve = ys, t;
+}
+function gs(e, t, n, s, {
+  value: r,
+  label: i
+}) {
+  return [t, {
+    value: typeof r == "function" ? r(n, s) : r,
+    label: i
+  }, void 0];
+}
+function ms({
+  logger: e
+}, {
+  value: t,
+  label: n
+}) {
+  n ? e(n, t) : e(t);
+}
+function Fs(e = ({
+  context: n,
+  event: s
+}) => ({
+  context: n,
+  event: s
+}), t) {
+  function n(s, r) {
+  }
+  return n.type = "xstate.log", n.value = e, n.label = t, n.resolve = gs, n.execute = ms, n;
+}
+function S(e, t) {
+  const n = C(t);
+  if (!n.includes(e.type)) {
+    const s = n.length === 1 ? `type "${n[0]}"` : `one of types "${n.join('", "')}"`;
+    throw new Error(`Expected event ${JSON.stringify(e)} to have ${s}`);
+  }
+}
+function vs(e, t) {
+  return new Pe(e, t);
+}
+function ze({
+  schemas: e,
+  actors: t,
+  actions: n,
+  guards: s,
+  delays: r
+}) {
+  return {
+    createMachine: (i) => vs({
+      ...i,
+      schemas: e
+    }, {
+      actors: t,
+      actions: n,
+      guards: s,
+      delays: r
+    })
+  };
+}
+var Se = { exports: {} }, be = {}, we = { exports: {} }, Ee = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var at;
+function _s() {
+  if (at) return Ee;
+  at = 1;
+  var e = lt;
+  function t(u, c) {
+    return u === c && (u !== 0 || 1 / u === 1 / c) || u !== u && c !== c;
+  }
+  var n = typeof Object.is == "function" ? Object.is : t, s = e.useState, r = e.useEffect, i = e.useLayoutEffect, o = e.useDebugValue;
+  function a(u, c) {
+    var l = c(), f = s({ inst: { value: l, getSnapshot: c } }), p = f[0].inst, g = f[1];
+    return i(
+      function() {
+        p.value = l, p.getSnapshot = c, d(p) && g({ inst: p });
+      },
+      [u, l, c]
+    ), r(
+      function() {
+        return d(p) && g({ inst: p }), u(function() {
+          d(p) && g({ inst: p });
+        });
+      },
+      [u]
+    ), o(l), l;
+  }
+  function d(u) {
+    var c = u.getSnapshot;
+    u = u.value;
+    try {
+      var l = c();
+      return !n(u, l);
+    } catch {
+      return !0;
+    }
+  }
+  function h(u, c) {
+    return c();
+  }
+  var y = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? h : a;
+  return Ee.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : y, Ee;
+}
+var ct;
+function Ht() {
+  return ct || (ct = 1, we.exports = _s()), we.exports;
+}
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ut;
+function Ss() {
+  if (ut) return be;
+  ut = 1;
+  var e = lt, t = Ht();
+  function n(h, y) {
+    return h === y && (h !== 0 || 1 / h === 1 / y) || h !== h && y !== y;
+  }
+  var s = typeof Object.is == "function" ? Object.is : n, r = t.useSyncExternalStore, i = e.useRef, o = e.useEffect, a = e.useMemo, d = e.useDebugValue;
+  return be.useSyncExternalStoreWithSelector = function(h, y, u, c, l) {
+    var f = i(null);
+    if (f.current === null) {
+      var p = { hasValue: !1, value: null };
+      f.current = p;
+    } else p = f.current;
+    f = a(
+      function() {
+        function m(T) {
+          if (!v) {
+            if (v = !0, _ = T, T = c(T), l !== void 0 && p.hasValue) {
+              var V = p.value;
+              if (l(V, T))
+                return w = V;
+            }
+            return w = T;
+          }
+          if (V = w, s(_, T)) return V;
+          var Ge = c(T);
+          return l !== void 0 && l(V, Ge) ? (_ = T, V) : (_ = T, w = Ge);
+        }
+        var v = !1, _, w, te = u === void 0 ? null : u;
+        return [
+          function() {
+            return m(y());
+          },
+          te === null ? void 0 : function() {
+            return m(te());
+          }
+        ];
+      },
+      [y, u, c, l]
+    );
+    var g = r(h, f[0], f[1]);
+    return o(
+      function() {
+        p.hasValue = !0, p.value = g;
+      },
+      [g]
+    ), d(g), g;
+  }, be;
+}
+var dt;
+function bs() {
+  return dt || (dt = 1, Se.exports = Ss()), Se.exports;
+}
+var ws = bs(), Qs = Ht();
+const Ut = (e, t) => {
+  t(e);
+  const n = e.getSnapshot().children;
+  n && Object.values(n).forEach((s) => {
+    Ut(s, t);
+  });
+};
+function Es(e) {
+  var s, r;
+  const t = [];
+  Ut(e, (i) => {
+    t.push([i, i.getSnapshot()]), i.observers = /* @__PURE__ */ new Set();
+  });
+  const n = (r = (s = e.system).getSnapshot) == null ? void 0 : r.call(s);
+  e.stop(), e.system._snapshot = n, t.forEach(([i, o]) => {
+    i._processingStatus = 0, i._snapshot = o;
+  });
+}
+function Ts(e, ...[t]) {
+  let [[n, s], r] = Nt(() => {
+    const i = $(e, t);
+    return [e.config, i];
+  });
+  if (e.config !== n) {
+    const i = $(e, {
+      ...t,
+      snapshot: s.getPersistedSnapshot({
+        __unsafeAllowInlineActors: !0
+      })
+    });
+    r([e.config, i]), s = i;
+  }
+  return nn(() => {
+    s.logic.implementations = e.implementations;
+  }), s;
+}
+function er(e, ...[t, n]) {
+  const s = Ts(e, t);
+  return Ne(() => {
+    if (!n)
+      return;
+    const r = s.subscribe(ae(n));
+    return () => {
+      r.unsubscribe();
+    };
+  }, [n]), Ne(() => (s.start(), () => {
+    Es(s);
+  }), [s]), s;
+}
+function xs(e, t) {
+  return e === t;
+}
+function tr(e, t, n = xs) {
+  const s = Je((o) => {
+    if (!e)
+      return () => {
+      };
+    const {
+      unsubscribe: a
+    } = e.subscribe(o);
+    return a;
+  }, [e]), r = Je(() => e == null ? void 0 : e.getSnapshot(), [e]);
+  return ws.useSyncExternalStoreWithSelector(s, r, r, t, n);
+}
+const b = [];
+for (let e = 0; e < 256; ++e)
+  b.push((e + 256).toString(16).slice(1));
+function ks(e, t = 0) {
+  return (b[e[t + 0]] + b[e[t + 1]] + b[e[t + 2]] + b[e[t + 3]] + "-" + b[e[t + 4]] + b[e[t + 5]] + "-" + b[e[t + 6]] + b[e[t + 7]] + "-" + b[e[t + 8]] + b[e[t + 9]] + "-" + b[e[t + 10]] + b[e[t + 11]] + b[e[t + 12]] + b[e[t + 13]] + b[e[t + 14]] + b[e[t + 15]]).toLowerCase();
+}
+let Te;
+const Is = new Uint8Array(16);
+function As() {
+  if (!Te) {
+    if (typeof crypto > "u" || !crypto.getRandomValues)
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    Te = crypto.getRandomValues.bind(crypto);
+  }
+  return Te(Is);
+}
+const Cs = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), ft = { randomUUID: Cs };
+function B(e, t, n) {
+  var r;
+  if (ft.randomUUID && !e)
+    return ft.randomUUID();
+  e = e || {};
+  const s = e.random ?? ((r = e.rng) == null ? void 0 : r.call(e)) ?? As();
+  if (s.length < 16)
+    throw new Error("Random bytes length must be >= 16");
+  return s[6] = s[6] & 15 | 64, s[8] = s[8] & 63 | 128, ks(s);
+}
+const I = (e) => ({
+  context: t
+}) => {
+  const { count: n, include: s, exclude: r, responseType: i = "message.received" } = e;
+  return {
+    count: n,
+    domain: t.domain,
+    from: t.connectTo,
+    include: s ? Array.isArray(s) ? s : [s] : [],
+    exclude: r ? Array.isArray(r) ? r : [r] : [],
+    responseType: i,
+    target: t.target,
+    to: t.name
+  };
+}, Rs = (e) => (t) => {
+  const { data: n } = t;
+  return (e.include.length ? e.include.includes(n.type) : !0) && (e.exclude.length ? !e.exclude.includes(n.type) : !0) && n.domain === e.domain && n.from === e.from && n.to === e.to && (!e.target || t.source === e.target);
+}, Ms = (e) => (t) => ({
+  type: e,
+  message: t
+}), $s = Xt(
+  () => Ie(window, "message")
+), Wt = (e) => Vt(({ input: t }) => $s.pipe(
+  e ? Ae(e) : ge(),
+  yt(Rs(t)),
+  Ae(Ms(t.responseType)),
+  t.count ? ge(
+    tn(t.count),
+    Yt((n) => n),
+    Oe(t.count)
+  ) : ge()
+)), Bt = "sanity/comlink", Ls = 3e3, qs = 1e4, Os = 500, P = "comlink/response", Z = "comlink/heartbeat", Y = "comlink/disconnect", re = "comlink/handshake/syn", Pt = "comlink/handshake/syn-ack", ie = "comlink/handshake/ack", js = (e) => (t) => t.pipe(
+  Oe(1),
+  Ae(() => {
+    throw new Error(e);
+  })
+), zt = () => ze({
+  actors: {
+    listen: Vt(
+      ({
+        input: e
+      }) => {
+        const t = e.signal ? Ie(e.signal, "abort").pipe(
+          js(`Request ${e.requestId} aborted`)
+        ) : Kt, n = (s) => {
+          var r, i;
+          return ((r = s.data) == null ? void 0 : r.type) === P && ((i = s.data) == null ? void 0 : i.responseTo) === e.requestId && !!s.source && e.sources.has(s.source);
+        };
+        return Ie(window, "message").pipe(
+          yt(n),
+          Oe(e.sources.size),
+          Zt(t)
+        );
+      }
+    )
+  },
+  actions: {
+    "send message": ({ context: e }, t) => {
+      const { sources: n, targetOrigin: s } = e, { message: r } = t;
+      n.forEach((i) => {
+        i.postMessage(r, { targetOrigin: s });
+      });
+    },
+    "on success": K(
+      ({ context: e }) => e.parentRef,
+      ({ context: e, self: t }) => {
+        var n;
+        return e.response && ((n = e.resolvable) == null || n.resolve(e.response)), {
+          type: "request.success",
+          requestId: t.id,
+          response: e.response,
+          responseTo: e.responseTo
+        };
+      }
+    ),
+    "on fail": K(
+      ({ context: e }) => e.parentRef,
+      ({ context: e, self: t }) => {
+        var n;
+        return e.suppressWarnings || console.warn(
+          `[@sanity/comlink] Received no response to message '${e.type}' on client '${e.from}' (ID: '${e.id}').`
+        ), (n = e.resolvable) == null || n.reject(new Error("No response received")), { type: "request.failed", requestId: t.id };
+      }
+    ),
+    "on abort": K(
+      ({ context: e }) => e.parentRef,
+      ({ context: e, self: t }) => {
+        var n;
+        return (n = e.resolvable) == null || n.reject(new Error("Request aborted")), { type: "request.aborted", requestId: t.id };
+      }
+    )
+  },
+  guards: {
+    expectsResponse: ({ context: e }) => e.expectResponse
+  },
+  delays: {
+    initialTimeout: 0,
+    responseTimeout: ({ context: e }) => e.responseTimeout ?? Ls
+  }
+}).createMachine({
+  /** @xstate-layout N4IgpgJg5mDOIC5QAoC2BDAxgCwJYDswBKAOlwgBswBiAD1gBd0GwT0AzFgJ2QNwdzoKAFVyowAewCuDItTRY8hUuSoBtAAwBdRKAAOE2P1wT8ukLUQBGAEwBWEgBYAnK+eOAzB7sB2DzY8rABoQAE9rDQc3V0cNTw8fAA4NHwBfVJCFHAJiElgwfAgCKGpNHSQQAyMBU3NLBDsrDxI7DTaAjQA2OOcNDxDwhHsNJx9Ou0TOq2cJxP9HdMyMbOU8gqL8ErUrcv1DY1qK+sbm1vaPLp6+gcRnGydo9wDGycWQLKVc9AB3dGNN6jiWCwdAwMrmKoHMxHRCJRKOEiJHwuZKBZwXKzBMKIGyYkhtAkXOweTqOHw2RJvD45Ug-P4CAH0JgsNicMA8LhwAz4fKicTSWTyZafWm-f5QcEVSE1aGgepwhFIlF9aYYrGDC4+JzEppjGzOUkeGbpDIgfASCBwczU5QQ-YyuqIAC0nRuCBd+IJXu9KSpwppZEoYDt1RMsosiEcNjdVjiJEeGisiSTHkcVgWpptuXyhWKIahjqGzi1BqRJINnVcdkcbuTLS9VYC8ISfsUAbp4vzDphCHJIyjBvJNlxNmRNexQ3sJGH43GPj8jWJrZWuXYfyoEC7YcLsbrgRsjkcvkmdgNbopVhIPhVfnsh8ClMz-tWsCkmEwcHgUvt257u8v+6Hse4xnhOdZnImVidPqCRNB4JqpEAA */
+  context: ({ input: e }) => ({
+    channelId: e.channelId,
+    data: e.data,
+    domain: e.domain,
+    expectResponse: e.expectResponse ?? !1,
+    from: e.from,
+    id: `msg-${B()}`,
+    parentRef: e.parentRef,
+    resolvable: e.resolvable,
+    response: null,
+    responseTimeout: e.responseTimeout,
+    responseTo: e.responseTo,
+    signal: e.signal,
+    sources: e.sources instanceof Set ? e.sources : /* @__PURE__ */ new Set([e.sources]),
+    suppressWarnings: e.suppressWarnings,
+    targetOrigin: e.targetOrigin,
+    to: e.to,
+    type: e.type
+  }),
+  initial: "idle",
+  on: {
+    abort: ".aborted"
+  },
+  states: {
+    idle: {
+      after: {
+        initialTimeout: [
+          {
+            target: "sending"
+          }
+        ]
+      }
+    },
+    sending: {
+      entry: {
+        type: "send message",
+        params: ({ context: e }) => {
+          const { channelId: t, data: n, domain: s, from: r, id: i, responseTo: o, to: a, type: d } = e;
+          return { message: {
+            channelId: t,
+            data: n,
+            domain: s,
+            from: r,
+            id: i,
+            to: a,
+            type: d,
+            responseTo: o
+          } };
+        }
+      },
+      always: [
+        {
+          guard: "expectsResponse",
+          target: "awaiting"
+        },
+        "success"
+      ]
+    },
+    awaiting: {
+      invoke: {
+        id: "listen for response",
+        src: "listen",
+        input: ({ context: e }) => ({
+          requestId: e.id,
+          sources: e.sources,
+          signal: e.signal
+        }),
+        onError: "aborted"
+      },
+      after: {
+        responseTimeout: "failed"
+      },
+      on: {
+        message: {
+          actions: M({
+            response: ({ event: e }) => e.data.data,
+            responseTo: ({ event: e }) => e.data.responseTo
+          }),
+          target: "success"
+        }
+      }
+    },
+    failed: {
+      type: "final",
+      entry: "on fail"
+    },
+    success: {
+      type: "final",
+      entry: "on success"
+    },
+    aborted: {
+      type: "final",
+      entry: "on abort"
+    }
+  },
+  output: ({ context: e, self: t }) => ({
+    requestId: t.id,
+    response: e.response,
+    responseTo: e.responseTo
+  })
+}), Ds = rs(({ sendBack: e, input: t }) => {
+  const n = () => {
+    e(t.event);
+  };
+  t.immediate && n();
+  const s = setInterval(n, t.interval);
+  return () => {
+    clearInterval(s);
+  };
+}), Gt = () => ze({
+  actors: {
+    requestMachine: zt(),
+    listen: Wt(),
+    sendBackAtInterval: Ds
+  },
+  actions: {
+    "buffer message": A(({ enqueue: e }) => {
+      e.assign({
+        buffer: ({ event: t, context: n }) => (S(t, "post"), [...n.buffer, t.data])
+      }), e.emit(({ event: t }) => (S(t, "post"), {
+        type: "buffer.added",
+        message: t.data
+      }));
+    }),
+    "create request": M({
+      requests: ({ context: e, event: t, self: n, spawn: s }) => {
+        S(t, "request");
+        const r = (Array.isArray(t.data) ? t.data : [t.data]).map((i) => {
+          const o = `req-${B()}`;
+          return s("requestMachine", {
+            id: o,
+            input: {
+              channelId: e.channelId,
+              data: i.data,
+              domain: e.domain,
+              expectResponse: i.expectResponse,
+              from: e.name,
+              parentRef: n,
+              responseTo: i.responseTo,
+              sources: e.target,
+              targetOrigin: e.targetOrigin,
+              to: e.connectTo,
+              type: i.type
+            }
+          });
+        });
+        return [...e.requests, ...r];
+      }
+    }),
+    "emit received message": A(({ enqueue: e }) => {
+      e.emit(({ event: t }) => (S(t, "message.received"), {
+        type: "message",
+        message: t.message.data
+      }));
+    }),
+    "emit status": pe((e, t) => ({
+      type: "status",
+      status: t.status
+    })),
+    "post message": x(({ event: e }) => (S(e, "post"), {
+      type: "request",
+      data: {
+        data: e.data.data,
+        expectResponse: !0,
+        type: e.data.type
+      }
+    })),
+    "remove request": A(({ context: e, enqueue: t, event: n }) => {
+      S(n, ["request.success", "request.failed", "request.aborted"]), F(n.requestId), t.assign({ requests: e.requests.filter(({ id: s }) => s !== n.requestId) });
+    }),
+    respond: x(({ event: e }) => (S(e, "response"), {
+      type: "request",
+      data: {
+        data: e.data,
+        type: P,
+        responseTo: e.respondTo
+      }
+    })),
+    "send handshake ack": x({
+      type: "request",
+      data: { type: ie }
+    }),
+    "send disconnect": x(() => ({
+      type: "request",
+      data: { type: Y }
+    })),
+    "send handshake syn": x({
+      type: "request",
+      data: { type: re }
+    }),
+    "send pending messages": A(({ enqueue: e }) => {
+      e.raise(({ context: t }) => ({
+        type: "request",
+        data: t.buffer.map(({ data: n, type: s }) => ({ data: n, type: s }))
+      })), e.emit(({ context: t }) => ({
+        type: "buffer.flushed",
+        messages: t.buffer
+      })), e.assign({
+        buffer: []
+      });
+    }),
+    "set target": M({
+      target: ({ event: e }) => (S(e, "target.set"), e.target)
+    })
+  },
+  guards: {
+    "has target": ({ context: e }) => !!e.target,
+    "should send heartbeats": ({ context: e }) => e.heartbeat
+  }
+}).createMachine({
+  /** @xstate-layout N4IgpgJg5mDOIC5QGMAWBDAdpsAbAxAC7oBOMhAdLGIQNoAMAuoqAA4D2sAloV+5ixAAPRAHZRAJgoAWABz0ArHICMy2QGZZCgJwAaEAE9EE+tIrb6ANgkLl46fTuj1AXxf60WHARJgAjgCucJSwAcjIcLAMzEggHNy8-IIiCKLS2hQS6qb2yurisrL6RgjK9LIyCuqq0g7WstZuHhjYePi+gcEUAGboXLiQ0YLxPHwCsSmiCgoykpayDtqS6trqxYjKEk0gnq24FFwQA-jI-DjIdEzDnKNJExuOZpZ12eq29OrSCuupypYUojUaTKCnm5Wk2123gORzA+HilxibBuiXGoBSGnUAIU4gU9FWamUtR+lmUM1EllBEkslMUEnpkJa0JaEFgGAA1lxMFB8LADJghrERqjkhtshk3mTtNo5OpqpYfqCKhTptoqpY1WUtu4dky8BQWWz0Jzue1-EFYIjrgkxqLSupqRRPpoPqJtLI0hIioZENJJE7NnJ8ZYHVk1YyvPrDRyuTyEYLkTa7uixVlMh81KGFhS1j6EPkZlpVjTphr8mkI3sDVhWTHTQBbSLoGAUXwRLgAN0GVyFKNt91KimUFEKXvKC2s9R+6X+jipnzJeSqEJ1UKjNaNJp5EC4sFOrQuCbifeTwg2cgoym0RPxDtqkj0eaB9Ao8zSolMEivZVcq71+33c5CEgeFOCtXskzRM8EDxKRpmkSw3QJbQsmpH5tHmV8JHSbJpDsakV2aSMALOMALhAjoLXAxNbiglI-SxWw1Vw0QNDw0Qfg9KQ7EJSxHHxApK2hQCyOAiAzVgDhMGoI9hX7FMEHSF8cWkelpHURCbBsb481xAEgT9BQJCmWQsiE-URPI8TG1gWBmzAVsyLATtuyRY9ILtWoKmlL82Kqd0tAVJ91LMHFZDKIkVlkNVZHMkiDzE-Adz3UjDx7GiRQHCKnheD53k+HSSkDDIwpBVTqQwuKKEssSDTAUhCAAI3qyg0DIrd8Fkk86MQUMnVM+RynoegTDJH48hGp0vR-FDRqqKqasgOqGua9AQjATAd1NSiul6fpXOtWi7Wy19cslD4vnG7IX3oVjVDUVYEJQqrksW8SdstLqPKy0wKgG1RhtMWogqKhoMjkWp6XxUyFBe3c3tAz70vco6fq+V8PTkGUFzdQqNnELEM2yClrwwzQ4ZShKQJqr7UYU98AS0W9pT4z5pHG0yXwMkNNTyGk3B1TB2AgOBBDXXBDsyhSFG9EovQqN5i1JeRcKqw4Bkl+ToMx8x0j+EaqQ9XMSkBURMgMkEwQWKro2NWNNdPFJAzN0lJGM4slDxhBEJfXyplBd03wW1KxIdnrBxBh4JAyW75C8rJpmDqmIGWkgmpasPjqUcaHooMLHA0uU1UkJOgKW1B6rT1bWor5At0zgcTAkK7hrz1irB0D8cW0UvRPLyv07WqgNq2qAG+l9SnXUz0UOXD5xuMs3Y4+DVJBX7UiKrV6Q8gcfoJO54rFefLLqfJYX1WKYNLxL4NO1NwgA */
+  id: "connection",
+  context: ({ input: e }) => ({
+    id: e.id || `${e.name}-${B()}`,
+    buffer: [],
+    channelId: `chn-${B()}`,
+    connectTo: e.connectTo,
+    domain: e.domain ?? Bt,
+    heartbeat: e.heartbeat ?? !1,
+    name: e.name,
+    requests: [],
+    target: e.target,
+    targetOrigin: e.targetOrigin
+  }),
+  on: {
+    "target.set": {
+      actions: "set target"
+    },
+    "request.success": {
+      actions: "remove request"
+    },
+    "request.failed": {
+      actions: "remove request"
+    }
+  },
+  initial: "idle",
+  states: {
+    idle: {
+      entry: [{ type: "emit status", params: { status: "idle" } }],
+      on: {
+        connect: {
+          target: "handshaking",
+          guard: "has target"
+        },
+        post: {
+          actions: "buffer message"
+        }
+      }
+    },
+    handshaking: {
+      id: "handshaking",
+      entry: [{ type: "emit status", params: { status: "handshaking" } }],
+      invoke: [
+        {
+          id: "send syn",
+          src: "sendBackAtInterval",
+          input: () => ({
+            event: { type: "syn" },
+            interval: Os,
+            immediate: !0
+          })
+        },
+        {
+          id: "listen for handshake",
+          src: "listen",
+          input: (e) => I({
+            include: Pt,
+            count: 1
+          })(e)
+          /* Below would maybe be more readable than transitioning to
+          'connected' on 'message', and 'ack' on exit but having onDone when
+          using passing invocations currently breaks XState Editor */
+          // onDone: {
+          //   target: 'connected',
+          //   actions: 'ack',
+          // },
+        }
+      ],
+      on: {
+        syn: {
+          actions: "send handshake syn"
+        },
+        request: {
+          actions: "create request"
+        },
+        post: {
+          actions: "buffer message"
+        },
+        "message.received": {
+          target: "connected"
+        },
+        disconnect: {
+          target: "disconnected"
+        }
+      },
+      exit: "send handshake ack"
+    },
+    connected: {
+      entry: ["send pending messages", { type: "emit status", params: { status: "connected" } }],
+      invoke: {
+        id: "listen for messages",
+        src: "listen",
+        input: I({
+          exclude: [P, Z]
+        })
+      },
+      on: {
+        post: {
+          actions: "post message"
+        },
+        request: {
+          actions: "create request"
+        },
+        response: {
+          actions: "respond"
+        },
+        "message.received": {
+          actions: "emit received message"
+        },
+        disconnect: {
+          target: "disconnected"
+        }
+      },
+      initial: "heartbeat",
+      states: {
+        heartbeat: {
+          initial: "checking",
+          states: {
+            checking: {
+              always: {
+                guard: "should send heartbeats",
+                target: "sending"
+              }
+            },
+            sending: {
+              on: {
+                "request.failed": {
+                  target: "#handshaking"
+                }
+              },
+              invoke: {
+                id: "send heartbeat",
+                src: "sendBackAtInterval",
+                input: () => ({
+                  event: { type: "post", data: { type: Z, data: void 0 } },
+                  interval: 2e3,
+                  immediate: !1
+                })
+              }
+            }
+          }
+        }
+      }
+    },
+    disconnected: {
+      id: "disconnected",
+      entry: ["send disconnect", { type: "emit status", params: { status: "disconnected" } }],
+      on: {
+        request: {
+          actions: "create request"
+        },
+        post: {
+          actions: "buffer message"
+        },
+        connect: {
+          target: "handshaking",
+          guard: "has target"
+        }
+      }
+    }
+  }
+}), xe = (e, t = Gt()) => {
+  const n = e.id || `${e.name}-${B()}`, s = $(t, {
+    input: { ...e, id: n }
+  }), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), o = (f, p, g) => {
+    const m = r.get(f) || /* @__PURE__ */ new Set();
+    r.has(f) || r.set(f, m), m.add(p);
+    const v = i.get(f);
+    if (v) {
+      const _ = (g == null ? void 0 : g.replay) ?? 1;
+      Array.from(v).slice(-_).forEach(async ({ data: w, id: te }) => {
+        const T = await p(w);
+        T && s.send({
+          type: "response",
+          respondTo: te,
+          data: T
+        });
+      }), i.delete(f);
+    }
+    return () => {
+      m.delete(p);
+    };
+  }, a = () => {
+    s.send({ type: "connect" });
+  }, d = () => {
+    s.send({ type: "disconnect" });
+  }, h = (f, p) => {
+    const { unsubscribe: g } = s.on("status", (m) => {
+      p && m.status !== p || f(m.status);
+    });
+    return g;
+  }, y = (f) => {
+    s.send({ type: "target.set", target: f });
+  }, u = (f, p) => {
+    const g = { type: f, data: p };
+    s.send({ type: "post", data: g });
+  };
+  s.on("message", async ({ message: f }) => {
+    const p = r.get(f.type);
+    if (p) {
+      p.forEach(async (m) => {
+        const v = await m(f.data);
+        v && s.send({ type: "response", respondTo: f.id, data: v });
+      });
+      return;
+    }
+    const g = i.get(f.type);
+    g ? g.add(f) : i.set(f.type, /* @__PURE__ */ new Set([f]));
+  });
+  const c = () => {
+    s.stop();
+  }, l = () => (s.start(), c);
+  return {
+    actor: s,
+    connect: a,
+    disconnect: d,
+    id: n,
+    name: e.name,
+    machine: t,
+    on: o,
+    onStatus: h,
+    post: u,
+    setTarget: y,
+    start: l,
+    stop: c,
+    get target() {
+      return s.getSnapshot().context.target;
+    }
+  };
+}, ke = (e) => {
+  e.disconnect(), setTimeout(() => {
+    e.stop();
+  }, 0);
+}, Vs = () => {
+}, nr = (e) => {
+  const { targetOrigin: t } = e, n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  return {
+    addTarget: (r) => {
+      if (n.has(r))
+        return Vs;
+      if (!n.size || !s.size)
+        return n.add(r), s.forEach((o) => {
+          o.connections.forEach((a) => {
+            a.setTarget(r), a.connect();
+          });
+        }), () => {
+          n.delete(r), s.forEach((o) => {
+            o.connections.forEach((a) => {
+              a.target === r && a.disconnect();
+            });
+          });
+        };
+      n.add(r);
+      const i = /* @__PURE__ */ new Set();
+      return s.forEach((o) => {
+        const a = xe(
+          {
+            ...o.input,
+            target: r,
+            targetOrigin: t
+          },
+          o.machine
+        );
+        i.add(a), o.connections.add(a), o.subscribers.forEach(({ type: d, handler: h, unsubscribers: y }) => {
+          y.push(a.on(d, h));
+        }), o.internalEventSubscribers.forEach(({ type: d, handler: h, unsubscribers: y }) => {
+          y.push(a.actor.on(d, h).unsubscribe);
+        }), o.statusSubscribers.forEach(({ handler: d, unsubscribers: h }) => {
+          h.push(
+            a.onStatus((y) => d({ connection: a.id, status: y }))
+          );
+        }), a.start(), a.connect();
+      }), () => {
+        n.delete(r), i.forEach((o) => {
+          ke(o), s.forEach((a) => {
+            a.connections.delete(o);
+          });
+        });
+      };
+    },
+    createChannel: (r, i = Gt()) => {
+      const o = {
+        connections: /* @__PURE__ */ new Set(),
+        input: r,
+        internalEventSubscribers: /* @__PURE__ */ new Set(),
+        machine: i,
+        statusSubscribers: /* @__PURE__ */ new Set(),
+        subscribers: /* @__PURE__ */ new Set()
+      };
+      s.add(o);
+      const { connections: a, internalEventSubscribers: d, statusSubscribers: h, subscribers: y } = o;
+      if (n.size)
+        n.forEach((g) => {
+          const m = xe(
+            {
+              ...r,
+              target: g,
+              targetOrigin: t
+            },
+            i
+          );
+          a.add(m);
+        });
+      else {
+        const g = xe({ ...r, targetOrigin: t }, i);
+        a.add(g);
+      }
+      const u = (...g) => {
+        const [m, v] = g;
+        a.forEach((_) => {
+          _.post(m, v);
+        });
+      }, c = (g, m) => {
+        const v = [];
+        a.forEach((w) => {
+          v.push(w.on(g, m));
+        });
+        const _ = { type: g, handler: m, unsubscribers: v };
+        return y.add(_), () => {
+          v.forEach((w) => w()), y.delete(_);
+        };
+      }, l = (g, m) => {
+        const v = [];
+        a.forEach((w) => {
+          v.push(w.actor.on(g, m).unsubscribe);
+        });
+        const _ = { type: g, handler: m, unsubscribers: v };
+        return d.add(_), () => {
+          v.forEach((w) => w()), d.delete(_);
+        };
+      }, f = (g) => {
+        const m = [];
+        a.forEach((_) => {
+          m.push(
+            _.onStatus((w) => g({ connection: _.id, status: w }))
+          );
+        });
+        const v = { handler: g, unsubscribers: m };
+        return h.add(v), () => {
+          m.forEach((_) => _()), h.delete(v);
+        };
+      }, p = () => {
+        const g = o.connections;
+        g.forEach(ke), g.clear(), s.delete(o);
+      };
+      return {
+        on: c,
+        onInternalEvent: l,
+        onStatus: f,
+        post: u,
+        start: () => (a.forEach((g) => {
+          g.start(), g.connect();
+        }), p),
+        stop: p
+      };
+    },
+    destroy: () => {
+      s.forEach(({ connections: r }) => {
+        r.forEach(ke), r.clear();
+      }), s.clear(), n.clear();
+    }
+  };
+};
+function Hs() {
+  if (typeof Promise.withResolvers == "function")
+    return Promise.withResolvers();
+  let e, t;
+  return { promise: new Promise((n, s) => {
+    e = n, t = s;
+  }), resolve: e, reject: t };
+}
+const Us = () => ze({
+  actors: {
+    requestMachine: zt(),
+    listen: Wt()
+  },
+  actions: {
+    "buffer handshake": M({
+      handshakeBuffer: ({ event: e, context: t }) => (S(e, "message.received"), [...t.handshakeBuffer, e])
+    }),
+    "buffer message": A(({ enqueue: e }) => {
+      e.assign({
+        buffer: ({ event: t, context: n }) => (S(t, "post"), [
+          ...n.buffer,
+          {
+            data: t.data,
+            resolvable: t.resolvable,
+            options: t.options
+          }
+        ])
+      }), e.emit(({ event: t }) => (S(t, "post"), {
+        type: "buffer.added",
+        message: t.data
+      }));
+    }),
+    "create request": M({
+      requests: ({ context: e, event: t, self: n, spawn: s }) => {
+        S(t, "request");
+        const r = (Array.isArray(t.data) ? t.data : [t.data]).map((i) => {
+          var a, d, h;
+          const o = `req-${B()}`;
+          return s("requestMachine", {
+            id: o,
+            input: {
+              channelId: e.channelId,
+              data: i.data,
+              domain: e.domain,
+              expectResponse: i.expectResponse,
+              from: e.name,
+              parentRef: n,
+              resolvable: i.resolvable,
+              responseTimeout: (a = i.options) == null ? void 0 : a.responseTimeout,
+              responseTo: i.responseTo,
+              signal: (d = i.options) == null ? void 0 : d.signal,
+              sources: e.target,
+              suppressWarnings: (h = i.options) == null ? void 0 : h.suppressWarnings,
+              targetOrigin: e.targetOrigin,
+              to: e.connectTo,
+              type: i.type
+            }
+          });
+        });
+        return [...e.requests, ...r];
+      }
+    }),
+    "emit heartbeat": pe(() => ({
+      type: "heartbeat"
+    })),
+    "emit received message": A(({ enqueue: e }) => {
+      e.emit(({ event: t }) => (S(t, "message.received"), {
+        type: "message",
+        message: t.message.data
+      }));
+    }),
+    "emit status": pe((e, t) => ({
+      type: "status",
+      status: t.status
+    })),
+    "post message": x(({ event: e }) => (S(e, "post"), {
+      type: "request",
+      data: {
+        data: e.data.data,
+        expectResponse: !!e.resolvable,
+        type: e.data.type,
+        resolvable: e.resolvable,
+        options: e.options
+      }
+    })),
+    "process pending handshakes": A(({ context: e, enqueue: t }) => {
+      e.handshakeBuffer.forEach((n) => t.raise(n)), t.assign({
+        handshakeBuffer: []
+      });
+    }),
+    "remove request": A(({ context: e, enqueue: t, event: n }) => {
+      S(n, ["request.success", "request.failed", "request.aborted"]), F(n.requestId), t.assign({ requests: e.requests.filter(({ id: s }) => s !== n.requestId) });
+    }),
+    "send response": x(({ event: e }) => (S(e, ["message.received", "heartbeat.received"]), {
+      type: "request",
+      data: {
+        type: P,
+        responseTo: e.message.data.id,
+        data: void 0
+      }
+    })),
+    "send handshake syn ack": x({
+      type: "request",
+      data: { type: Pt }
+    }),
+    "send pending messages": A(({ enqueue: e }) => {
+      e.raise(({ context: t }) => ({
+        type: "request",
+        data: t.buffer.map(({ data: n, resolvable: s, options: r }) => ({
+          data: n.data,
+          type: n.type,
+          expectResponse: !!s,
+          resolvable: s,
+          options: r
+        }))
+      })), e.emit(({ context: t }) => ({
+        type: "buffer.flushed",
+        messages: t.buffer.map(({ data: n }) => n)
+      })), e.assign({
+        buffer: []
+      });
+    }),
+    "set connection config": M({
+      channelId: ({ event: e }) => (S(e, "handshake.syn"), e.message.data.channelId),
+      target: ({ event: e }) => (S(e, "handshake.syn"), e.message.source || void 0),
+      targetOrigin: ({ event: e }) => (S(e, "handshake.syn"), e.message.origin)
+    })
+  },
+  guards: {
+    hasSource: ({ context: e }) => e.target !== null
+  }
+}).createMachine({
+  /** @xstate-layout N4IgpgJg5mDOIC5QDsD2EwGIBOYCOArnAC4B0sBAxpXLANoAMAuoqAA6qwCWxXqyrEAA9EAVgYAWUgEYJDUQA4JAZmUSJC0coDsAGhABPRNIYLSErdOkBOAGzbx227YUBfV-rQYc+IrDIAZgCGXAA2kIwsSCAc3Lz8giIIoiakqgBMDKbp2tYS0srp+kYI0ununuhgpFwQ4ZgQ-NVcyABuqADW1V7NdWAILe2UQfHIkZGCsTx8AtFJ6aKipAzWOtrpC7Z5BUWGiNoK6aS26RLW2tLaqkqqFSA9NX2YALa0QTCkuDRcrRHMk5xpgk5ogJLZSNZIVDoVCFLZiohbIVSLkXLZRHZDgxbHcHrV6rFiBNolNRolEVJbCsdGUzsoyhiEcllOC1DowelVmVrOUPPcqqQABZBZAQWDCjotKANJo1NqdboC4Wi8VBSXIKADeXDUbjf4kwFkkEILbg8RZMHKOzWKzKJkHJa086Xa4qZS4pUisUSqU+QgkYnsQ0zcnJaRLDbpZwKNQSBYspm2MEyC5KTnaDSSd18h7K71q32EwMxYPA0BJFLKY5yZxIrKSURM0RnFHSBTrQqQ9babQejBCr2q9XSiBcWCUfjIMCUIn6oNxEPGtTWFFR0RUy7iGzt+3Ip0XURXVZKPvVCfIKczyB+vyzqLzoGzcuIG0MGTyCztjRtjaJjbHVMNAUTdu1PUhz0vYhryLOcSwXMthBfK0ZGsLQGBZekCi0Jso1IdI23WG04zOE4wIg6coIgBox3Imdi1JRdnxNOxSHNSQkWtW0mTjMxMQ7fDzgcbNKn7WjKJeN4Pi+MAfj+e84MfUMFHbZZwxOHZNDyO09gQOQjmAhZJCM9IMjIycKOvQUwCCbBiAAI2sshpNkiB6NLJ9EIQBQbWOdJlMhYCUjbJkchXGsFmsJQMVsWl3BzKp4GiHoAXgjykgAWmkZZ6xy3LZF2EobCy6xsQWJQ42kE4FjA-EwBSxTjSRUhDgqkzgO2BxdykU4AvXFQ-KjMC8yHKV6qNJi6WOdcypcZsXGxe0JG0XySKjM5lKsMyLwsiAxsYzylDfONznUEqrmi+1ThkHqXDONbULi1wgA */
+  id: "node",
+  context: ({ input: e }) => ({
+    buffer: [],
+    channelId: null,
+    connectTo: e.connectTo,
+    domain: e.domain ?? Bt,
+    handshakeBuffer: [],
+    name: e.name,
+    requests: [],
+    target: void 0,
+    targetOrigin: null
+  }),
+  // Always listen for handshake syn messages. The channel could have
+  // disconnected without being able to notify the node, and so need to
+  // re-establish the connection.
+  invoke: {
+    id: "listen for handshake syn",
+    src: "listen",
+    input: I({
+      include: re,
+      responseType: "handshake.syn"
+    })
+  },
+  on: {
+    "request.success": {
+      actions: "remove request"
+    },
+    "request.failed": {
+      actions: "remove request"
+    },
+    "request.aborted": {
+      actions: "remove request"
+    },
+    "handshake.syn": {
+      actions: "set connection config",
+      target: ".handshaking"
+    }
+  },
+  initial: "idle",
+  states: {
+    idle: {
+      entry: [{ type: "emit status", params: { status: "idle" } }],
+      on: {
+        post: {
+          actions: "buffer message"
+        }
+      }
+    },
+    handshaking: {
+      guard: "hasSource",
+      entry: ["send handshake syn ack", { type: "emit status", params: { status: "handshaking" } }],
+      invoke: [
+        {
+          id: "listen for handshake ack",
+          src: "listen",
+          input: I({
+            include: ie,
+            count: 1,
+            // Override the default `message.received` responseType to prevent
+            // buffering the ack message. We transition to the connected state
+            // using onDone instead of listening to this event using `on`
+            responseType: "handshake.complete"
+          }),
+          onDone: "connected"
+        },
+        {
+          id: "listen for disconnect",
+          src: "listen",
+          input: I({
+            include: Y,
+            count: 1,
+            responseType: "disconnect"
+          })
+        },
+        {
+          id: "listen for messages",
+          src: "listen",
+          input: I({
+            exclude: [
+              Y,
+              re,
+              ie,
+              Z,
+              P
+            ]
+          })
+        }
+      ],
+      on: {
+        request: {
+          actions: "create request"
+        },
+        post: {
+          actions: "buffer message"
+        },
+        "message.received": {
+          actions: "buffer handshake"
+        },
+        disconnect: {
+          target: "idle"
+        }
+      }
+    },
+    connected: {
+      entry: [
+        "process pending handshakes",
+        "send pending messages",
+        { type: "emit status", params: { status: "connected" } }
+      ],
+      invoke: [
+        {
+          id: "listen for messages",
+          src: "listen",
+          input: I({
+            exclude: [
+              Y,
+              re,
+              ie,
+              Z,
+              P
+            ]
+          })
+        },
+        {
+          id: "listen for heartbeat",
+          src: "listen",
+          input: I({
+            include: Z,
+            responseType: "heartbeat.received"
+          })
+        },
+        {
+          id: "listen for disconnect",
+          src: "listen",
+          input: I({
+            include: Y,
+            count: 1,
+            responseType: "disconnect"
+          })
+        }
+      ],
+      on: {
+        request: {
+          actions: "create request"
+        },
+        post: {
+          actions: "post message"
+        },
+        disconnect: {
+          target: "idle"
+        },
+        "message.received": {
+          actions: ["send response", "emit received message"]
+        },
+        "heartbeat.received": {
+          actions: ["send response", "emit heartbeat"]
+        }
+      }
+    }
+  }
+}), sr = (e, t = Us()) => {
+  const n = $(t, {
+    input: e
+  }), s = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = (u, c, l) => {
+    const f = s.get(u) || /* @__PURE__ */ new Set();
+    s.has(u) || s.set(u, f), f.add(c);
+    const p = r.get(u);
+    if (p) {
+      const g = (l == null ? void 0 : l.replay) ?? 1;
+      Array.from(p).slice(-g).forEach(({ data: m }) => c(m)), r.delete(u);
+    }
+    return () => {
+      f.delete(c);
+    };
+  };
+  let o;
+  const a = (u, c) => {
+    const { unsubscribe: l } = n.on(
+      "status",
+      (f) => {
+        o = f.status, !(c && f.status !== c) && u(f.status);
+      }
+    );
+    return o && u(o), l;
+  }, d = (u, c) => {
+    const l = { type: u, data: c };
+    n.send({ type: "post", data: l });
+  }, h = (u, c, l) => {
+    const { responseTimeout: f = qs, signal: p, suppressWarnings: g } = l || {}, m = Hs(), v = { type: u, data: c };
+    return n.send({
+      type: "post",
+      data: v,
+      resolvable: m,
+      options: { responseTimeout: f, signal: p, suppressWarnings: g }
+    }), m.promise;
+  };
+  n.on("message", ({ message: u }) => {
+    const c = s.get(u.type);
+    if (c) {
+      c.forEach((f) => f(u.data));
+      return;
+    }
+    const l = r.get(u.type);
+    l ? l.add(u) : r.set(u.type, /* @__PURE__ */ new Set([u]));
+  });
+  const y = () => {
+    n.stop();
+  };
+  return {
+    actor: n,
+    fetch: h,
+    machine: t,
+    on: i,
+    onStatus: a,
+    post: d,
+    start: () => (n.start(), y),
+    stop: y
+  };
+}, Ws = "#FF5500", oe = "#0D0E12", rr = /* @__PURE__ */ pt(function(e, t) {
+  const { dark: n, ...s } = e, r = n ? Ce.hex : oe;
+  return /* @__PURE__ */ gt(
+    "svg",
+    {
+      "data-sanity-icon": "sanity-logo",
+      height: "1em",
+      viewBox: "0 0 435 154",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...s,
+      ref: t,
+      children: [
+        /* @__PURE__ */ R(
+          "path",
+          {
+            d: "M44.883 52.4463C33.4181 43.7972 21.8121 37.1021 21.8121 27.3381C21.8121 21.482 26.9827 15.4851 34.1181 15.4851C46.983 15.4851 54.5302 28.8754 61.942 45.6103H66.5538V7.11182H34.3946C7.82952 7.11182 0 23.1543 0 35.7055C0 52.1647 13.5649 61.9287 28.9416 73.365C39.7064 81.3158 48.7948 88.7092 48.7948 97.2175C48.7948 106.424 42.5006 111.723 34.5299 111.723C26.0004 111.723 13.4178 100.562 4.60595 77.4137H0V120.096H36.777C59.4302 120.096 70.7539 102.24 71.1716 87.876C71.7304 71.1411 57.3302 61.7937 44.883 52.4463Z",
+            fill: r
+          }
+        ),
+        /* @__PURE__ */ R(
+          "path",
+          {
+            d: "M145.002 106.841V61.7878C145.002 42.2598 132.837 37.1021 115.219 37.1021H83.8952L84.0364 68.9054H89.2071C94.6601 55.3743 102.49 45.4754 110.878 45.4754C118.149 45.4754 121.366 51.7539 121.366 58.3082V64.4459C109.619 71.4227 78.301 77.2788 78.301 98.4791C78.301 110.754 86.8306 120.935 99.2778 120.935C110.043 120.935 117.454 113.958 121.231 105.732C121.931 112.568 126.402 120.096 136.614 120.096H152.696V113.958C147.525 113.958 145.008 110.473 145.008 106.847L145.002 106.841ZM120.949 99.8639C118.713 103.074 115.213 106.7 111.019 106.7C105.148 106.7 101.372 102.234 101.372 93.3096C101.372 83.129 115.072 76.5746 120.949 71.6926V99.8697V99.8639Z",
+            fill: r
+          }
+        ),
+        /* @__PURE__ */ R(
+          "path",
+          {
+            d: "M270.145 28.4529C279.092 28.4529 284.686 22.1744 284.686 14.0885C284.686 6.00274 279.092 0 270.145 0C261.198 0 255.462 5.99688 255.462 14.0885C255.462 22.1802 261.474 28.4529 270.145 28.4529Z",
+            fill: r
+          }
+        ),
+        /* @__PURE__ */ R(
+          "path",
+          {
+            d: "M409.135 37.102V43.2397C417.947 43.2397 420.459 47.84 416.129 60.2563L405.641 88.5683L392.217 54.1186C389.141 47.4234 390.817 43.2397 397.252 43.2397V37.102H330.557V9.20654H324.263C322.446 18.6889 312.516 37.102 295.598 37.102V43.2397H306.504V100.568C306.504 110.191 309.722 121.07 328.457 121.07H357.54V89.5482H352.37C350.269 96.9417 345.94 111.723 336.569 111.723C331.399 111.723 330.557 106.002 330.557 101.401V45.8861H357.264C360.481 45.8861 363.834 46.3027 365.511 50.2106L393.894 120.231C388.441 132.647 379.07 134.595 362.293 129.437V153.988C366.629 153.988 377.811 154.129 379.77 153.572C390.817 150.362 398.364 128.745 401.441 120.378L425.488 55.521C428.147 48.4092 430.382 43.2456 434.994 43.2456V37.1079H409.129L409.135 37.102Z",
+            fill: r
+          }
+        ),
+        /* @__PURE__ */ R(
+          "path",
+          {
+            d: "M237.703 106.841V59.2764C237.703 44.3546 230.574 35.4238 216.45 35.4238C204.009 35.4238 196.803 44.0319 191.279 52.0414V37.0961H159.396V43.2338C164.849 43.2338 167.226 46.5785 167.226 50.4864V106.835C167.226 110.602 164.432 113.947 159.396 113.947V120.084H199.109V113.947C194.073 113.947 191.279 110.602 191.279 106.835V59.646C194.503 55.3743 198.214 50.7681 204.42 50.7681C210.291 50.7681 213.65 55.5093 213.65 61.2303V106.841C213.65 110.608 210.856 113.952 205.82 113.952V120.09H245.533V113.952C240.497 113.952 237.703 110.608 237.703 106.841Z",
+            fill: r
+          }
+        ),
+        /* @__PURE__ */ R(
+          "path",
+          {
+            d: "M284.127 106.841V37.1021H252.245V43.2398C257.698 43.2398 260.074 46.5844 260.074 50.4923V106.841C260.074 110.608 257.28 113.952 252.245 113.952V120.09H291.957V113.952C286.922 113.952 284.127 110.608 284.127 106.841Z",
+            fill: r
+          }
+        )
+      ]
+    }
+  );
+}), ht = {
+  light: { bg: Ce.hex, fg: oe },
+  dark: { bg: oe, fg: Ce.hex },
+  default: { bg: Ws, fg: oe }
+}, ir = /* @__PURE__ */ pt(function(e, t) {
+  const { scheme: n = "default", color: s, ...r } = e, i = (s == null ? void 0 : s.bg1) || ht[n].bg, o = (s == null ? void 0 : s.fg) || ht[n].fg;
+  return /* @__PURE__ */ gt(
+    "svg",
+    {
+      "data-sanity-icon": "sanity-monogram",
+      height: "1em",
+      viewBox: "0 0 192 192",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...r,
+      ref: t,
+      children: [
+        /* @__PURE__ */ R("rect", { width: "192", height: "192", fill: i }),
+        /* @__PURE__ */ R(
+          "path",
+          {
+            d: "M160.077 112.697L154.865 103.629L129.659 118.981L157.655 83.3368L161.888 80.8533L160.841 79.2802L162.764 76.8232L153.929 69.4699L149.886 74.6225L68.2657 122.375L98.4429 86.0855L154.651 55.2759L149.311 44.953L118.696 61.7277L133.771 43.6096L125.134 36L91.2055 76.7966L57.5083 95.2771L83.307 61.1709L99.4731 52.757L94.3391 42.3192L47.2403 66.8361L60.0839 49.8405L51.1123 42.6551L24 78.5378L24.4207 78.8736L29.486 89.1877L59.543 73.5354L32.1474 109.745L36.6375 113.342L39.3075 118.504L70.9528 101.154L36.1052 143.065L44.742 150.674L46.4762 148.588L130.543 99.2454L102.632 134.792L103.088 135.172L103.045 135.199L108.831 145.265L145.954 122.649L131.659 145.716L141.24 152L164 115.278L160.077 112.697Z",
+            fill: o
+          }
+        )
+      ]
+    }
+  );
+});
+export {
+  sr as A,
+  Qs as B,
+  rr as C,
+  Bt as D,
+  Y as M,
+  ir as S,
+  zt as a,
+  Wt as b,
+  Gt as c,
+  Z as d,
+  P as e,
+  ie as f,
+  Pt as g,
+  re as h,
+  M as i,
+  nr as j,
+  er as k,
+  Zs as l,
+  Fs as m,
+  Ks as n,
+  $ as o,
+  pe as p,
+  Ns as q,
+  A as r,
+  ze as s,
+  S as t,
+  tr as u,
+  B as v,
+  Ys as w,
+  Xs as x,
+  x as y,
+  rs as z
+};
+//# sourceMappingURL=index-DCkQlgdi.mjs.map