nmea-web-serial 1.0.0

package/dist/nmea-web-serial.js

@@ -0,0 +1,3858 @@
+function Tn() {
+  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 In() {
+  const e = Tn();
+  if (e.__xstate__)
+    return e.__xstate__;
+}
+const wn = (e) => {
+  if (typeof window > "u")
+    return;
+  const t = In();
+  t && t.register(e);
+};
+class ft {
+  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 Yt = ".", kn = "", Zt = "", Pn = "#", Dn = "*", Xt = "xstate.init", Mn = "xstate.error", ke = "xstate.stop";
+function An(e, t) {
+  return {
+    type: `xstate.after.${e}.${t}`
+  };
+}
+function ze(e, t) {
+  return {
+    type: `xstate.done.state.${e}`,
+    output: t
+  };
+}
+function En(e, t) {
+  return {
+    type: `xstate.done.actor.${e}`,
+    output: t,
+    actorId: e
+  };
+}
+function Qt(e, t) {
+  return {
+    type: `xstate.error.actor.${e}`,
+    error: t,
+    actorId: e
+  };
+}
+function $t(e) {
+  return {
+    type: Xt,
+    input: e
+  };
+}
+function j(e) {
+  setTimeout(() => {
+    throw e;
+  });
+}
+const Fn = typeof Symbol == "function" && Symbol.observable || "@@observable";
+function en(e, t) {
+  const n = lt(e), r = lt(t);
+  return typeof r == "string" ? typeof n == "string" ? r === n : !1 : typeof n == "string" ? n in r : Object.keys(n).every((i) => i in r ? en(n[i], r[i]) : !1);
+}
+function $e(e) {
+  if (nn(e))
+    return e;
+  const t = [];
+  let n = "";
+  for (let r = 0; r < e.length; r++) {
+    switch (e.charCodeAt(r)) {
+      // \
+      case 92:
+        n += e[r + 1], r++;
+        continue;
+      // .
+      case 46:
+        t.push(n), n = "";
+        continue;
+    }
+    n += e[r];
+  }
+  return t.push(n), t;
+}
+function lt(e) {
+  if (ur(e))
+    return e.value;
+  if (typeof e != "string")
+    return e;
+  const t = $e(e);
+  return On(t);
+}
+function On(e) {
+  if (e.length === 1)
+    return e[0];
+  const t = {};
+  let n = t;
+  for (let r = 0; r < e.length - 1; r++)
+    if (r === e.length - 2)
+      n[e[r]] = e[r + 1];
+    else {
+      const i = n;
+      n = {}, i[e[r]] = n;
+    }
+  return t;
+}
+function ht(e, t) {
+  const n = {}, r = Object.keys(e);
+  for (let i = 0; i < r.length; i++) {
+    const o = r[i];
+    n[o] = t(e[o], o, e, i);
+  }
+  return n;
+}
+function tn(e) {
+  return nn(e) ? e : [e];
+}
+function q(e) {
+  return e === void 0 ? [] : tn(e);
+}
+function Je(e, t, n, r) {
+  return typeof e == "function" ? e({
+    context: t,
+    event: n,
+    self: r
+  }) : e;
+}
+function nn(e) {
+  return Array.isArray(e);
+}
+function Nn(e) {
+  return e.type.startsWith("xstate.error.actor");
+}
+function Z(e) {
+  return tn(e).map((t) => typeof t > "u" || typeof t == "string" ? {
+    target: t
+  } : t);
+}
+function rn(e) {
+  if (!(e === void 0 || e === kn))
+    return q(e);
+}
+function Ye(e, t, n) {
+  const r = typeof e == "object", i = r ? e : void 0;
+  return {
+    next: (r ? e.next : e)?.bind(i),
+    error: (r ? e.error : t)?.bind(i),
+    complete: (r ? e.complete : n)?.bind(i)
+  };
+}
+function pt(e, t) {
+  return `${t}.${e}`;
+}
+function et(e, t) {
+  const n = t.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+  if (!n)
+    return e.implementations.actors[t];
+  const [, r, i] = n, s = e.getStateNodeById(i).config.invoke;
+  return (Array.isArray(s) ? s[r] : s).src;
+}
+function vt(e, t) {
+  return `${e.sessionId}.${t}`;
+}
+let Cn = 0;
+function Rn(e, t) {
+  const n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new Set(), s = {}, {
+    clock: a,
+    logger: c
+  } = t, u = {
+    schedule: (d, p, v, y, I = Math.random().toString(36).slice(2)) => {
+      const N = {
+        source: d,
+        target: p,
+        event: v,
+        delay: y,
+        id: I,
+        startedAt: Date.now()
+      }, C = vt(d, I);
+      l._snapshot._scheduledEvents[C] = N;
+      const K = a.setTimeout(() => {
+        delete s[C], delete l._snapshot._scheduledEvents[C], l._relay(d, p, v);
+      }, y);
+      s[C] = K;
+    },
+    cancel: (d, p) => {
+      const v = vt(d, p), y = s[v];
+      delete s[v], delete l._snapshot._scheduledEvents[v], y !== void 0 && a.clearTimeout(y);
+    },
+    cancelAll: (d) => {
+      for (const p in l._snapshot._scheduledEvents) {
+        const v = l._snapshot._scheduledEvents[p];
+        v.source === d && u.cancel(d, v.id);
+      }
+    }
+  }, f = (d) => {
+    if (!o.size)
+      return;
+    const p = {
+      ...d,
+      rootId: e.sessionId
+    };
+    o.forEach((v) => v.next?.(p));
+  }, l = {
+    _snapshot: {
+      _scheduledEvents: (t?.snapshot && t.snapshot.scheduler) ?? {}
+    },
+    _bookId: () => `x:${Cn++}`,
+    _register: (d, p) => (n.set(d, p), d),
+    _unregister: (d) => {
+      n.delete(d.sessionId);
+      const p = i.get(d);
+      p !== void 0 && (r.delete(p), i.delete(d));
+    },
+    get: (d) => r.get(d),
+    getAll: () => Object.fromEntries(r.entries()),
+    _set: (d, p) => {
+      const v = r.get(d);
+      if (v && v !== p)
+        throw new Error(`Actor with system ID '${d}' already exists.`);
+      r.set(d, p), i.set(p, d);
+    },
+    inspect: (d) => {
+      const p = Ye(d);
+      return o.add(p), {
+        unsubscribe() {
+          o.delete(p);
+        }
+      };
+    },
+    _sendInspectionEvent: f,
+    _relay: (d, p, v) => {
+      l._sendInspectionEvent({
+        type: "@xstate.event",
+        sourceRef: d,
+        actorRef: p,
+        event: v
+      }), p._send(v);
+    },
+    scheduler: u,
+    getSnapshot: () => ({
+      _scheduledEvents: {
+        ...l._snapshot._scheduledEvents
+      }
+    }),
+    start: () => {
+      const d = l._snapshot._scheduledEvents;
+      l._snapshot._scheduledEvents = {};
+      for (const p in d) {
+        const {
+          source: v,
+          target: y,
+          event: I,
+          delay: N,
+          id: C
+        } = d[p];
+        u.schedule(v, y, I, N, C);
+      }
+    },
+    _clock: a,
+    _logger: c
+  };
+  return l;
+}
+let Be = !1;
+const tt = 1;
+let A = /* @__PURE__ */ (function(e) {
+  return e[e.NotStarted = 0] = "NotStarted", e[e.Running = 1] = "Running", e[e.Stopped = 2] = "Stopped", e;
+})({});
+const jn = {
+  clock: {
+    setTimeout: (e, t) => setTimeout(e, t),
+    clearTimeout: (e) => clearTimeout(e)
+  },
+  logger: console.log.bind(console),
+  devTools: !1
+};
+class Gn {
+  /**
+   * 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 ft(this._process.bind(this)), this.observers = /* @__PURE__ */ new Set(), this.eventListeners = /* @__PURE__ */ new Map(), this.logger = void 0, this._processingStatus = A.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 r = {
+      ...jn,
+      ...n
+    }, {
+      clock: i,
+      logger: o,
+      parent: s,
+      syncSnapshot: a,
+      id: c,
+      systemId: u,
+      inspect: f
+    } = r;
+    this.system = s ? s.system : Rn(this, {
+      clock: i,
+      logger: o
+    }), f && !s && this.system.inspect(Ye(f)), this.sessionId = this.system._bookId(), this.id = c ?? this.sessionId, this.logger = n?.logger ?? this.system._logger, this.clock = n?.clock ?? this.system._clock, this._parent = s, this._syncSnapshot = a, this.options = r, this.src = r.src ?? t, this.ref = this, this._actorScope = {
+      self: this,
+      id: this.id,
+      sessionId: this.sessionId,
+      logger: this.logger,
+      defer: (l) => {
+        this._deferred.push(l);
+      },
+      system: this.system,
+      stopChild: (l) => {
+        if (l._parent !== this)
+          throw new Error(`Cannot stop child actor ${l.id} of ${this.id} because it is not a child`);
+        l._stop();
+      },
+      emit: (l) => {
+        const d = this.eventListeners.get(l.type), p = this.eventListeners.get("*");
+        if (!d && !p)
+          return;
+        const v = [...d ? d.values() : [], ...p ? p.values() : []];
+        for (const y of v)
+          try {
+            y(l);
+          } catch (I) {
+            j(I);
+          }
+      },
+      actionExecutor: (l) => {
+        const d = () => {
+          if (this._actorScope.system._sendInspectionEvent({
+            type: "@xstate.action",
+            actorRef: this,
+            action: {
+              type: l.type,
+              params: l.params
+            }
+          }), !l.exec)
+            return;
+          const p = Be;
+          try {
+            Be = !0, l.exec(l.info, l.params);
+          } finally {
+            Be = p;
+          }
+        };
+        this._processingStatus === A.Running ? d() : this._deferred.push(d);
+      }
+    }, this.send = this.send.bind(this), this.system._sendInspectionEvent({
+      type: "@xstate.actor",
+      actorRef: this
+    }), u && (this.systemId = u, this.system._set(u, this)), this._initState(n?.snapshot ?? n?.state), u && this._snapshot.status !== "active" && this.system._unregister(this);
+  }
+  _initState(t) {
+    try {
+      this._snapshot = t ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(t, this._actorScope) : t : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);
+    } catch (n) {
+      this._snapshot = {
+        status: "error",
+        output: void 0,
+        error: n
+      };
+    }
+  }
+  update(t, n) {
+    this._snapshot = t;
+    let r;
+    for (; r = this._deferred.shift(); )
+      try {
+        r();
+      } catch (i) {
+        this._deferred.length = 0, this._snapshot = {
+          ...t,
+          status: "error",
+          error: i
+        };
+      }
+    switch (this._snapshot.status) {
+      case "active":
+        for (const i of this.observers)
+          try {
+            i.next?.(t);
+          } catch (o) {
+            j(o);
+          }
+        break;
+      case "done":
+        for (const i of this.observers)
+          try {
+            i.next?.(t);
+          } catch (o) {
+            j(o);
+          }
+        this._stopProcedure(), this._complete(), this._doneEvent = En(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, r) {
+    const i = Ye(t, n, r);
+    if (this._processingStatus !== A.Stopped)
+      this.observers.add(i);
+    else
+      switch (this._snapshot.status) {
+        case "done":
+          try {
+            i.complete?.();
+          } catch (o) {
+            j(o);
+          }
+          break;
+        case "error": {
+          const o = this._snapshot.error;
+          if (!i.error)
+            j(o);
+          else
+            try {
+              i.error(o);
+            } catch (s) {
+              j(s);
+            }
+          break;
+        }
+      }
+    return {
+      unsubscribe: () => {
+        this.observers.delete(i);
+      }
+    };
+  }
+  on(t, n) {
+    let r = this.eventListeners.get(t);
+    r || (r = /* @__PURE__ */ new Set(), this.eventListeners.set(t, r));
+    const i = n.bind(void 0);
+    return r.add(i), {
+      unsubscribe: () => {
+        r.delete(i);
+      }
+    };
+  }
+  /** Starts the Actor from the initial state */
+  start() {
+    if (this._processingStatus === A.Running)
+      return this;
+    this._syncSnapshot && this.subscribe({
+      next: (r) => {
+        r.status === "active" && this.system._relay(this, this._parent, {
+          type: `xstate.snapshot.${this.id}`,
+          snapshot: r
+        });
+      },
+      error: () => {
+      }
+    }), this.system._register(this.sessionId, this), this.systemId && this.system._set(this.systemId, this), this._processingStatus = A.Running;
+    const t = $t(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 (r) {
+        return this._snapshot = {
+          ...this._snapshot,
+          status: "error",
+          error: r
+        }, this._error(r), this;
+      }
+    return this.update(this._snapshot, t), this.options.devTools && this.attachDevTools(), this.mailbox.start(), this;
+  }
+  _process(t) {
+    let n, r;
+    try {
+      n = this.logic.transition(this._snapshot, t, this._actorScope);
+    } catch (i) {
+      r = {
+        err: i
+      };
+    }
+    if (r) {
+      const {
+        err: i
+      } = r;
+      this._snapshot = {
+        ...this._snapshot,
+        status: "error",
+        error: i
+      }, this._error(i);
+      return;
+    }
+    this.update(n, t), t.type === ke && (this._stopProcedure(), this._complete());
+  }
+  _stop() {
+    return this._processingStatus === A.Stopped ? this : (this.mailbox.clear(), this._processingStatus === A.NotStarted ? (this._processingStatus = A.Stopped, this) : (this.mailbox.enqueue({
+      type: ke
+    }), 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() {
+    for (const t of this.observers)
+      try {
+        t.complete?.();
+      } catch (n) {
+        j(n);
+      }
+    this.observers.clear();
+  }
+  _reportError(t) {
+    if (!this.observers.size) {
+      this._parent || j(t);
+      return;
+    }
+    let n = !1;
+    for (const r of this.observers) {
+      const i = r.error;
+      n ||= !i;
+      try {
+        i?.(t);
+      } catch (o) {
+        j(o);
+      }
+    }
+    this.observers.clear(), n && j(t);
+  }
+  _error(t) {
+    this._stopProcedure(), this._reportError(t), this._parent && this.system._relay(this, this._parent, Qt(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 !== A.Running ? this : (this.system.scheduler.cancelAll(this), this.mailbox.clear(), this.mailbox = new ft(this._process.bind(this)), this._processingStatus = A.Stopped, this.system._unregister(this), this);
+  }
+  /** @internal */
+  _send(t) {
+    this._processingStatus !== A.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 : wn)(this);
+  }
+  toJSON() {
+    return {
+      xstate$$type: tt,
+      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);
+  }
+  [Fn]() {
+    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 Ae(e, ...[t]) {
+  return new Gn(e, t);
+}
+function Ln(e, t, n, r, {
+  sendId: i
+}) {
+  const o = typeof i == "function" ? i(n, r) : i;
+  return [t, {
+    sendId: o
+  }, void 0];
+}
+function xn(e, t) {
+  e.defer(() => {
+    e.system.scheduler.cancel(e.self, t.sendId);
+  });
+}
+function nt(e) {
+  function t(n, r) {
+  }
+  return t.type = "xstate.cancel", t.sendId = e, t.resolve = Ln, t.execute = xn, t;
+}
+function qn(e, t, n, r, {
+  id: i,
+  systemId: o,
+  src: s,
+  input: a,
+  syncSnapshot: c
+}) {
+  const u = typeof s == "string" ? et(t.machine, s) : s, f = typeof i == "function" ? i(n) : i;
+  let l, d;
+  return u && (d = typeof a == "function" ? a({
+    context: t.context,
+    event: n.event,
+    self: e.self
+  }) : a, l = Ae(u, {
+    id: f,
+    src: s,
+    parent: e.self,
+    syncSnapshot: c,
+    systemId: o,
+    input: d
+  })), [V(t, {
+    children: {
+      ...t.children,
+      [f]: l
+    }
+  }), {
+    id: i,
+    systemId: o,
+    actorRef: l,
+    src: s,
+    input: d
+  }, void 0];
+}
+function Un(e, {
+  actorRef: t
+}) {
+  t && e.defer(() => {
+    t._processingStatus !== A.Stopped && t.start();
+  });
+}
+function rt(...[e, {
+  id: t,
+  systemId: n,
+  input: r,
+  syncSnapshot: i = !1
+} = {}]) {
+  function o(s, a) {
+  }
+  return o.type = "xstate.spawnChild", o.id = t, o.systemId = n, o.src = e, o.input = r, o.syncSnapshot = i, o.resolve = qn, o.execute = Un, o;
+}
+function Hn(e, t, n, r, {
+  actorRef: i
+}) {
+  const o = typeof i == "function" ? i(n, r) : i, s = typeof o == "string" ? t.children[o] : o;
+  let a = t.children;
+  return s && (a = {
+    ...a
+  }, delete a[s.id]), [V(t, {
+    children: a
+  }), s, void 0];
+}
+function Wn(e, t) {
+  if (t) {
+    if (e.system._unregister(t), t._processingStatus !== A.Running) {
+      e.stopChild(t);
+      return;
+    }
+    e.defer(() => {
+      e.stopChild(t);
+    });
+  }
+}
+function Ce(e) {
+  function t(n, r) {
+  }
+  return t.type = "xstate.stopChild", t.actorRef = e, t.resolve = Hn, t.execute = Wn, t;
+}
+function Re(e, t, n, r) {
+  const {
+    machine: i
+  } = r, o = typeof e == "function", s = o ? e : i.implementations.guards[typeof e == "string" ? e : e.type];
+  if (!o && !s)
+    throw new Error(`Guard '${typeof e == "string" ? e : e.type}' is not implemented.'.`);
+  if (typeof s != "function")
+    return Re(s, t, n, r);
+  const a = {
+    context: t,
+    event: n
+  }, c = o || 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 s ? s.check(
+    r,
+    a,
+    s
+    // this holds all params
+  ) : s(a, c);
+}
+const st = (e) => e.type === "atomic" || e.type === "final";
+function Q(e) {
+  return Object.values(e.states).filter((t) => t.type !== "history");
+}
+function Pe(e, t) {
+  const n = [];
+  if (t === e)
+    return n;
+  let r = e.parent;
+  for (; r && r !== t; )
+    n.push(r), r = r.parent;
+  return n;
+}
+function Ee(e) {
+  const t = new Set(e), n = on(t);
+  for (const r of t)
+    if (r.type === "compound" && (!n.get(r) || !n.get(r).length))
+      mt(r).forEach((i) => t.add(i));
+    else if (r.type === "parallel") {
+      for (const i of Q(r))
+        if (i.type !== "history" && !t.has(i)) {
+          const o = mt(i);
+          for (const s of o)
+            t.add(s);
+        }
+    }
+  for (const r of t) {
+    let i = r.parent;
+    for (; i; )
+      t.add(i), i = i.parent;
+  }
+  return t;
+}
+function sn(e, t) {
+  const n = t.get(e);
+  if (!n)
+    return {};
+  if (e.type === "compound") {
+    const i = n[0];
+    if (i) {
+      if (st(i))
+        return i.key;
+    } else
+      return {};
+  }
+  const r = {};
+  for (const i of n)
+    r[i.key] = sn(i, t);
+  return r;
+}
+function on(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 an(e, t) {
+  const n = Ee(t);
+  return sn(e, on(n));
+}
+function it(e, t) {
+  return t.type === "compound" ? Q(t).some((n) => n.type === "final" && e.has(n)) : t.type === "parallel" ? Q(t).every((n) => it(e, n)) : t.type === "final";
+}
+const je = (e) => e[0] === Pn;
+function Bn(e, t) {
+  return e.transitions.get(t) || [...e.transitions.keys()].filter((r) => {
+    if (r === Dn)
+      return !0;
+    if (!r.endsWith(".*"))
+      return !1;
+    const i = r.split("."), o = t.split(".");
+    for (let s = 0; s < i.length; s++) {
+      const a = i[s], c = o[s];
+      if (a === "*")
+        return s === i.length - 1;
+      if (a !== c)
+        return !1;
+    }
+    return !0;
+  }).sort((r, i) => i.length - r.length).flatMap((r) => e.transitions.get(r));
+}
+function Vn(e) {
+  const t = e.config.after;
+  if (!t)
+    return [];
+  const n = (i) => {
+    const o = An(i, e.id), s = o.type;
+    return e.entry.push(ct(o, {
+      id: s,
+      delay: i
+    })), e.exit.push(nt(s)), s;
+  };
+  return Object.keys(t).flatMap((i) => {
+    const o = t[i], s = typeof o == "string" ? {
+      target: o
+    } : o, a = Number.isNaN(+i) ? i : +i, c = n(a);
+    return q(s).map((u) => ({
+      ...u,
+      event: c,
+      delay: a
+    }));
+  }).map((i) => {
+    const {
+      delay: o
+    } = i;
+    return {
+      ...W(e, i.event, i),
+      delay: o
+    };
+  });
+}
+function W(e, t, n) {
+  const r = rn(n.target), i = n.reenter ?? !1, o = Jn(e, r), s = {
+    ...n,
+    actions: q(n.actions),
+    guard: n.guard,
+    target: o,
+    source: e,
+    reenter: i,
+    eventType: t,
+    toJSON: () => ({
+      ...s,
+      source: `#${e.id}`,
+      target: o ? o.map((a) => `#${a.id}`) : void 0
+    })
+  };
+  return s;
+}
+function Kn(e) {
+  const t = /* @__PURE__ */ new Map();
+  if (e.config.on)
+    for (const n of Object.keys(e.config.on)) {
+      if (n === Zt)
+        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+      const r = e.config.on[n];
+      t.set(n, Z(r).map((i) => W(e, n, i)));
+    }
+  if (e.config.onDone) {
+    const n = `xstate.done.state.${e.id}`;
+    t.set(n, Z(e.config.onDone).map((r) => W(e, n, r)));
+  }
+  for (const n of e.invoke) {
+    if (n.onDone) {
+      const r = `xstate.done.actor.${n.id}`;
+      t.set(r, Z(n.onDone).map((i) => W(e, r, i)));
+    }
+    if (n.onError) {
+      const r = `xstate.error.actor.${n.id}`;
+      t.set(r, Z(n.onError).map((i) => W(e, r, i)));
+    }
+    if (n.onSnapshot) {
+      const r = `xstate.snapshot.${n.id}`;
+      t.set(r, Z(n.onSnapshot).map((i) => W(e, r, i)));
+    }
+  }
+  for (const n of e.after) {
+    let r = t.get(n.eventType);
+    r || (r = [], t.set(n.eventType, r)), r.push(n);
+  }
+  return t;
+}
+function zn(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 r = {
+    source: e,
+    actions: !t || typeof t == "string" ? [] : q(t.actions),
+    eventType: null,
+    reenter: !1,
+    target: n ? [n] : [],
+    toJSON: () => ({
+      ...r,
+      source: `#${e.id}`,
+      target: n ? [`#${n.id}`] : []
+    })
+  };
+  return r;
+}
+function Jn(e, t) {
+  if (t !== void 0)
+    return t.map((n) => {
+      if (typeof n != "string")
+        return n;
+      if (je(n))
+        return e.machine.getStateNodeById(n);
+      const r = n[0] === Yt;
+      if (r && !e.parent)
+        return Fe(e, n.slice(1));
+      const i = r ? e.key + n : n;
+      if (e.parent)
+        try {
+          return Fe(e.parent, i);
+        } catch (o) {
+          throw new Error(`Invalid transition definition for state node '${e.id}':
+${o.message}`);
+        }
+      else
+        throw new Error(`Invalid target: "${n}" is not a valid target from the root node. Did you mean ".${n}"?`);
+    });
+}
+function cn(e) {
+  const t = rn(e.config.target);
+  return t ? {
+    target: t.map((n) => typeof n == "string" ? Fe(e.parent, n) : n)
+  } : e.parent.initial;
+}
+function B(e) {
+  return e.type === "history";
+}
+function mt(e) {
+  const t = un(e);
+  for (const n of t)
+    for (const r of Pe(n, e))
+      t.add(r);
+  return t;
+}
+function un(e) {
+  const t = /* @__PURE__ */ new Set();
+  function n(r) {
+    if (!t.has(r)) {
+      if (t.add(r), r.type === "compound")
+        n(r.initial.target[0]);
+      else if (r.type === "parallel")
+        for (const i of Q(r))
+          n(i);
+    }
+  }
+  return n(e), t;
+}
+function $(e, t) {
+  if (je(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 Fe(e, t) {
+  if (typeof t == "string" && je(t))
+    try {
+      return e.machine.getStateNodeById(t);
+    } catch {
+    }
+  const n = $e(t).slice();
+  let r = e;
+  for (; n.length; ) {
+    const i = n.shift();
+    if (!i.length)
+      break;
+    r = $(r, i);
+  }
+  return r;
+}
+function Oe(e, t) {
+  if (typeof t == "string") {
+    const i = e.states[t];
+    if (!i)
+      throw new Error(`State '${t}' does not exist on '${e.id}'`);
+    return [e, i];
+  }
+  const n = Object.keys(t), r = n.map((i) => $(e, i)).filter(Boolean);
+  return [e.machine.root, e].concat(r, n.reduce((i, o) => {
+    const s = $(e, o);
+    if (!s)
+      return i;
+    const a = Oe(s, t[o]);
+    return i.concat(a);
+  }, []));
+}
+function Yn(e, t, n, r) {
+  const o = $(e, t).next(n, r);
+  return !o || !o.length ? e.next(n, r) : o;
+}
+function Zn(e, t, n, r) {
+  const i = Object.keys(t), o = $(e, i[0]), s = ot(o, t[i[0]], n, r);
+  return !s || !s.length ? e.next(n, r) : s;
+}
+function Xn(e, t, n, r) {
+  const i = [];
+  for (const o of Object.keys(t)) {
+    const s = t[o];
+    if (!s)
+      continue;
+    const a = $(e, o), c = ot(a, s, n, r);
+    c && i.push(...c);
+  }
+  return i.length ? i : e.next(n, r);
+}
+function ot(e, t, n, r) {
+  return typeof t == "string" ? Yn(e, t, n, r) : Object.keys(t).length === 1 ? Zn(e, t, n, r) : Xn(e, t, n, r);
+}
+function Qn(e) {
+  return Object.keys(e.states).map((t) => e.states[t]).filter((t) => t.type === "history");
+}
+function U(e, t) {
+  let n = e;
+  for (; n.parent && n.parent !== t; )
+    n = n.parent;
+  return n.parent === t;
+}
+function $n(e, t) {
+  const n = new Set(e), r = new Set(t);
+  for (const i of n)
+    if (r.has(i))
+      return !0;
+  for (const i of r)
+    if (n.has(i))
+      return !0;
+  return !1;
+}
+function dn(e, t, n) {
+  const r = /* @__PURE__ */ new Set();
+  for (const i of e) {
+    let o = !1;
+    const s = /* @__PURE__ */ new Set();
+    for (const a of r)
+      if ($n(Ze([i], t, n), Ze([a], t, n)))
+        if (U(i.source, a.source))
+          s.add(a);
+        else {
+          o = !0;
+          break;
+        }
+    if (!o) {
+      for (const a of s)
+        r.delete(a);
+      r.add(i);
+    }
+  }
+  return Array.from(r);
+}
+function er(e) {
+  const [t, ...n] = e;
+  for (const r of Pe(t, void 0))
+    if (n.every((i) => U(i, r)))
+      return r;
+}
+function at(e, t) {
+  if (!e.target)
+    return [];
+  const n = /* @__PURE__ */ new Set();
+  for (const r of e.target)
+    if (B(r))
+      if (t[r.id])
+        for (const i of t[r.id])
+          n.add(i);
+      else
+        for (const i of at(cn(r), t))
+          n.add(i);
+    else
+      n.add(r);
+  return [...n];
+}
+function fn(e, t) {
+  const n = at(e, t);
+  if (!n)
+    return;
+  if (!e.reenter && n.every((i) => i === e.source || U(i, e.source)))
+    return e.source;
+  const r = er(n.concat(e.source));
+  if (r)
+    return r;
+  if (!e.reenter)
+    return e.source.machine.root;
+}
+function Ze(e, t, n) {
+  const r = /* @__PURE__ */ new Set();
+  for (const i of e)
+    if (i.target?.length) {
+      const o = fn(i, n);
+      i.reenter && i.source === o && r.add(o);
+      for (const s of t)
+        U(s, o) && r.add(s);
+    }
+  return [...r];
+}
+function tr(e, t) {
+  if (e.length !== t.size)
+    return !1;
+  for (const n of e)
+    if (!t.has(n))
+      return !1;
+  return !0;
+}
+function Xe(e, t, n, r, i, o) {
+  if (!e.length)
+    return t;
+  const s = new Set(t._nodes);
+  let a = t.historyValue;
+  const c = dn(e, s, a);
+  let u = t;
+  i || ([u, a] = ir(u, r, n, c, s, a, o, n.actionExecutor)), u = ee(u, r, n, c.flatMap((l) => l.actions), o, void 0), u = rr(u, r, n, c, s, o, a, i);
+  const f = [...s];
+  u.status === "done" && (u = ee(u, r, n, f.sort((l, d) => d.order - l.order).flatMap((l) => l.exit), o, void 0));
+  try {
+    return a === t.historyValue && tr(t._nodes, s) ? u : V(u, {
+      _nodes: f,
+      historyValue: a
+    });
+  } catch (l) {
+    throw l;
+  }
+}
+function nr(e, t, n, r, i) {
+  if (r.output === void 0)
+    return;
+  const o = ze(i.id, i.output !== void 0 && i.parent ? Je(i.output, e.context, t, n.self) : void 0);
+  return Je(r.output, e.context, o, n.self);
+}
+function rr(e, t, n, r, i, o, s, a) {
+  let c = e;
+  const u = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set();
+  sr(r, s, f, u), a && f.add(e.machine.root);
+  const l = /* @__PURE__ */ new Set();
+  for (const d of [...u].sort((p, v) => p.order - v.order)) {
+    i.add(d);
+    const p = [];
+    p.push(...d.entry);
+    for (const v of d.invoke)
+      p.push(rt(v.src, {
+        ...v,
+        syncSnapshot: !!v.onSnapshot
+      }));
+    if (f.has(d)) {
+      const v = d.initial.actions;
+      p.push(...v);
+    }
+    if (c = ee(c, t, n, p, o, d.invoke.map((v) => v.id)), d.type === "final") {
+      const v = d.parent;
+      let y = v?.type === "parallel" ? v : v?.parent, I = y || d;
+      for (v?.type === "compound" && o.push(ze(v.id, d.output !== void 0 ? Je(d.output, c.context, t, n.self) : void 0)); y?.type === "parallel" && !l.has(y) && it(i, y); )
+        l.add(y), o.push(ze(y.id)), I = y, y = y.parent;
+      if (y)
+        continue;
+      c = V(c, {
+        status: "done",
+        output: nr(c, t, n, c.machine.root, I)
+      });
+    }
+  }
+  return c;
+}
+function sr(e, t, n, r) {
+  for (const i of e) {
+    const o = fn(i, t);
+    for (const a of i.target || [])
+      !B(a) && // if the target is different than the source then it will *definitely* be entered
+      (i.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
+      i.source !== o || // reentering transitions always enter the target, even if it's the source itself
+      i.reenter) && (r.add(a), n.add(a)), X(a, t, n, r);
+    const s = at(i, t);
+    for (const a of s) {
+      const c = Pe(a, o);
+      o?.type === "parallel" && c.push(o), ln(r, t, n, c, !i.source.parent && i.reenter ? void 0 : o);
+    }
+  }
+}
+function X(e, t, n, r) {
+  if (B(e))
+    if (t[e.id]) {
+      const i = t[e.id];
+      for (const o of i)
+        r.add(o), X(o, t, n, r);
+      for (const o of i)
+        Ve(o, e.parent, r, t, n);
+    } else {
+      const i = cn(e);
+      for (const o of i.target)
+        r.add(o), i === e.parent?.initial && n.add(e.parent), X(o, t, n, r);
+      for (const o of i.target)
+        Ve(o, e.parent, r, t, n);
+    }
+  else if (e.type === "compound") {
+    const [i] = e.initial.target;
+    B(i) || (r.add(i), n.add(i)), X(i, t, n, r), Ve(i, e, r, t, n);
+  } else if (e.type === "parallel")
+    for (const i of Q(e).filter((o) => !B(o)))
+      [...r].some((o) => U(o, i)) || (B(i) || (r.add(i), n.add(i)), X(i, t, n, r));
+}
+function ln(e, t, n, r, i) {
+  for (const o of r)
+    if ((!i || U(o, i)) && e.add(o), o.type === "parallel")
+      for (const s of Q(o).filter((a) => !B(a)))
+        [...e].some((a) => U(a, s)) || (e.add(s), X(s, t, n, e));
+}
+function Ve(e, t, n, r, i) {
+  ln(n, r, i, Pe(e, t));
+}
+function ir(e, t, n, r, i, o, s, a) {
+  let c = e;
+  const u = Ze(r, i, o);
+  u.sort((l, d) => d.order - l.order);
+  let f;
+  for (const l of u)
+    for (const d of Qn(l)) {
+      let p;
+      d.history === "deep" ? p = (v) => st(v) && U(v, l) : p = (v) => v.parent === l, f ??= {
+        ...o
+      }, f[d.id] = Array.from(i).filter(p);
+    }
+  for (const l of u)
+    c = ee(c, t, n, [...l.exit, ...l.invoke.map((d) => Ce(d.id))], s, void 0), i.delete(l);
+  return [c, f || o];
+}
+function or(e, t) {
+  return e.implementations.actions[t];
+}
+function hn(e, t, n, r, i, o) {
+  const {
+    machine: s
+  } = e;
+  let a = e;
+  for (const c of r) {
+    const u = typeof c == "function", f = u ? c : (
+      // 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
+      or(s, typeof c == "string" ? c : c.type)
+    ), l = {
+      context: a.context,
+      event: t,
+      self: n.self,
+      system: n.system
+    }, d = u || typeof c == "string" ? void 0 : "params" in c ? typeof c.params == "function" ? c.params({
+      context: a.context,
+      event: t
+    }) : c.params : void 0;
+    if (!f || !("resolve" in f)) {
+      n.actionExecutor({
+        type: typeof c == "string" ? c : typeof c == "object" ? c.type : c.name || "(anonymous)",
+        info: l,
+        params: d,
+        exec: f
+      });
+      continue;
+    }
+    const p = f, [v, y, I] = p.resolve(
+      n,
+      a,
+      l,
+      d,
+      f,
+      // this holds all params
+      i
+    );
+    a = v, "retryResolve" in p && o?.push([p, y]), "execute" in p && n.actionExecutor({
+      type: p.type,
+      info: l,
+      params: y,
+      exec: p.execute.bind(null, n, y)
+    }), I && (a = hn(a, t, n, I, i, o));
+  }
+  return a;
+}
+function ee(e, t, n, r, i, o) {
+  const s = o ? [] : void 0, a = hn(e, t, n, r, {
+    internalQueue: i,
+    deferredActorIds: o
+  }, s);
+  return s?.forEach(([c, u]) => {
+    c.retryResolve(n, a, u);
+  }), a;
+}
+function Ke(e, t, n, r) {
+  let i = e;
+  const o = [];
+  function s(u, f, l) {
+    n.system._sendInspectionEvent({
+      type: "@xstate.microstep",
+      actorRef: n.self,
+      event: f,
+      snapshot: u,
+      _transitions: l
+    }), o.push(u);
+  }
+  if (t.type === ke)
+    return i = V(gt(i, t, n), {
+      status: "stopped"
+    }), s(i, t, []), {
+      snapshot: i,
+      microstates: o
+    };
+  let a = t;
+  if (a.type !== Xt) {
+    const u = a, f = Nn(u), l = yt(u, i);
+    if (f && !l.length)
+      return i = V(e, {
+        status: "error",
+        error: u.error
+      }), s(i, u, []), {
+        snapshot: i,
+        microstates: o
+      };
+    i = Xe(
+      l,
+      e,
+      n,
+      a,
+      !1,
+      // isInitial
+      r
+    ), s(i, u, l);
+  }
+  let c = !0;
+  for (; i.status === "active"; ) {
+    let u = c ? ar(i, a) : [];
+    const f = u.length ? i : void 0;
+    if (!u.length) {
+      if (!r.length)
+        break;
+      a = r.shift(), u = yt(a, i);
+    }
+    i = Xe(u, i, n, a, !1, r), c = i !== f, s(i, a, u);
+  }
+  return i.status !== "active" && gt(i, a, n), {
+    snapshot: i,
+    microstates: o
+  };
+}
+function gt(e, t, n) {
+  return ee(e, t, n, Object.values(e.children).map((r) => Ce(r)), [], void 0);
+}
+function yt(e, t) {
+  return t.machine.getTransitionData(t, e);
+}
+function ar(e, t) {
+  const n = /* @__PURE__ */ new Set(), r = e._nodes.filter(st);
+  for (const i of r)
+    e: for (const o of [i].concat(Pe(i, void 0)))
+      if (o.always) {
+        for (const s of o.always)
+          if (s.guard === void 0 || Re(s.guard, e.context, t, e)) {
+            n.add(s);
+            break e;
+          }
+      }
+  return dn(Array.from(n), new Set(e._nodes), e.historyValue);
+}
+function cr(e, t) {
+  const n = Ee(Oe(e, t));
+  return an(e, [...n]);
+}
+function ur(e) {
+  return !!e && typeof e == "object" && "machine" in e && "value" in e;
+}
+const dr = function(t) {
+  return en(t, this.value);
+}, fr = function(t) {
+  return this.tags.has(t);
+}, lr = function(t) {
+  const n = this.machine.getTransitionData(this, t);
+  return !!n?.length && // Check that at least one transition is not forbidden
+  n.some((r) => r.target !== void 0 || r.actions.length);
+}, hr = function() {
+  const {
+    _nodes: t,
+    tags: n,
+    machine: r,
+    getMeta: i,
+    toJSON: o,
+    can: s,
+    hasTag: a,
+    matches: c,
+    ...u
+  } = this;
+  return {
+    ...u,
+    tags: Array.from(n)
+  };
+}, pr = function() {
+  return this._nodes.reduce((t, n) => (n.meta !== void 0 && (t[n.id] = n.meta), t), {});
+};
+function Me(e, t) {
+  return {
+    status: e.status,
+    output: e.output,
+    error: e.error,
+    machine: t,
+    context: e.context,
+    _nodes: e._nodes,
+    value: an(t.root, e._nodes),
+    tags: new Set(e._nodes.flatMap((n) => n.tags)),
+    children: e.children,
+    historyValue: e.historyValue || {},
+    matches: dr,
+    hasTag: fr,
+    can: lr,
+    getMeta: pr,
+    toJSON: hr
+  };
+}
+function V(e, t = {}) {
+  return Me({
+    ...e,
+    ...t
+  }, e.machine);
+}
+function vr(e) {
+  if (typeof e != "object" || e === null)
+    return {};
+  const t = {};
+  for (const n in e) {
+    const r = e[n];
+    Array.isArray(r) && (t[n] = r.map((i) => ({
+      id: i.id
+    })));
+  }
+  return t;
+}
+function mr(e, t) {
+  const {
+    _nodes: n,
+    tags: r,
+    machine: i,
+    children: o,
+    context: s,
+    can: a,
+    hasTag: c,
+    matches: u,
+    getMeta: f,
+    toJSON: l,
+    ...d
+  } = e, p = {};
+  for (const y in o) {
+    const I = o[y];
+    p[y] = {
+      snapshot: I.getPersistedSnapshot(t),
+      src: I.src,
+      systemId: I.systemId,
+      syncSnapshot: I._syncSnapshot
+    };
+  }
+  return {
+    ...d,
+    context: pn(s),
+    children: p,
+    historyValue: vr(d.historyValue)
+  };
+}
+function pn(e) {
+  let t;
+  for (const n in e) {
+    const r = e[n];
+    if (r && typeof r == "object")
+      if ("sessionId" in r && "send" in r && "ref" in r)
+        t ??= Array.isArray(e) ? e.slice() : {
+          ...e
+        }, t[n] = {
+          xstate$$type: tt,
+          id: r.id
+        };
+      else {
+        const i = pn(r);
+        i !== r && (t ??= Array.isArray(e) ? e.slice() : {
+          ...e
+        }, t[n] = i);
+      }
+  }
+  return t ?? e;
+}
+function gr(e, t, n, r, {
+  event: i,
+  id: o,
+  delay: s
+}, {
+  internalQueue: a
+}) {
+  const c = 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 raise; use raise({ type: "${i}" }) instead`
+    );
+  const u = typeof i == "function" ? i(n, r) : i;
+  let f;
+  if (typeof s == "string") {
+    const l = c && c[s];
+    f = typeof l == "function" ? l(n, r) : l;
+  } else
+    f = typeof s == "function" ? s(n, r) : s;
+  return typeof f != "number" && a.push(u), [t, {
+    event: u,
+    id: o,
+    delay: f
+  }, void 0];
+}
+function yr(e, t) {
+  const {
+    event: n,
+    delay: r,
+    id: i
+  } = t;
+  if (typeof r == "number") {
+    e.defer(() => {
+      const o = e.self;
+      e.system.scheduler.schedule(o, o, n, r, i);
+    });
+    return;
+  }
+}
+function ct(e, t) {
+  function n(r, i) {
+  }
+  return n.type = "xstate.raise", n.event = e, n.id = t?.id, n.delay = t?.delay, n.resolve = gr, n.execute = yr, n;
+}
+const St = /* @__PURE__ */ new WeakMap();
+function Sr(e) {
+  return {
+    config: e,
+    start: (n, r) => {
+      const {
+        self: i,
+        system: o,
+        emit: s
+      } = r, a = {
+        receivers: void 0,
+        dispose: void 0
+      };
+      St.set(i, a), a.dispose = e({
+        input: n.input,
+        system: o,
+        self: i,
+        sendBack: (c) => {
+          i.getSnapshot().status !== "stopped" && i._parent && o._relay(i, i._parent, c);
+        },
+        receive: (c) => {
+          a.receivers ??= /* @__PURE__ */ new Set(), a.receivers.add(c);
+        },
+        emit: s
+      });
+    },
+    transition: (n, r, i) => {
+      const o = St.get(i.self);
+      return r.type === ke ? (n = {
+        ...n,
+        status: "stopped",
+        error: void 0
+      }, o.dispose?.(), n) : (o.receivers?.forEach((s) => s(r)), n);
+    },
+    getInitialSnapshot: (n, r) => ({
+      status: "active",
+      output: void 0,
+      error: void 0,
+      input: r
+    }),
+    getPersistedSnapshot: (n) => n,
+    restoreSnapshot: (n) => n
+  };
+}
+const _t = "xstate.promise.resolve", bt = "xstate.promise.reject", De = /* @__PURE__ */ new WeakMap();
+function vn(e) {
+  return {
+    config: e,
+    transition: (n, r, i) => {
+      if (n.status !== "active")
+        return n;
+      switch (r.type) {
+        case _t: {
+          const o = r.data;
+          return {
+            ...n,
+            status: "done",
+            output: o,
+            input: void 0
+          };
+        }
+        case bt:
+          return {
+            ...n,
+            status: "error",
+            error: r.data,
+            input: void 0
+          };
+        case ke:
+          return De.get(i.self)?.abort(), {
+            ...n,
+            status: "stopped",
+            input: void 0
+          };
+        default:
+          return n;
+      }
+    },
+    start: (n, {
+      self: r,
+      system: i,
+      emit: o
+    }) => {
+      if (n.status !== "active")
+        return;
+      const s = new AbortController();
+      De.set(r, s), Promise.resolve(e({
+        input: n.input,
+        system: i,
+        self: r,
+        signal: s.signal,
+        emit: o
+      })).then((c) => {
+        r.getSnapshot().status === "active" && (De.delete(r), i._relay(r, r, {
+          type: _t,
+          data: c
+        }));
+      }, (c) => {
+        r.getSnapshot().status === "active" && (De.delete(r), i._relay(r, r, {
+          type: bt,
+          data: c
+        }));
+      });
+    },
+    getInitialSnapshot: (n, r) => ({
+      status: "active",
+      output: void 0,
+      error: void 0,
+      input: r
+    }),
+    getPersistedSnapshot: (n) => n,
+    restoreSnapshot: (n) => n
+  };
+}
+function _r(e, {
+  machine: t,
+  context: n
+}, r, i) {
+  const o = (s, a) => {
+    if (typeof s == "string") {
+      const c = et(t, s);
+      if (!c)
+        throw new Error(`Actor logic '${s}' not implemented in machine '${t.id}'`);
+      const u = Ae(c, {
+        id: a?.id,
+        parent: e.self,
+        syncSnapshot: a?.syncSnapshot,
+        input: typeof a?.input == "function" ? a.input({
+          context: n,
+          event: r,
+          self: e.self
+        }) : a?.input,
+        src: s,
+        systemId: a?.systemId
+      });
+      return i[u.id] = u, u;
+    } else
+      return Ae(s, {
+        id: a?.id,
+        parent: e.self,
+        syncSnapshot: a?.syncSnapshot,
+        input: a?.input,
+        src: s,
+        systemId: a?.systemId
+      });
+  };
+  return (s, a) => {
+    const c = o(s, a);
+    return i[c.id] = c, e.defer(() => {
+      c._processingStatus !== A.Stopped && c.start();
+    }), c;
+  };
+}
+function br(e, t, n, r, {
+  assignment: i
+}) {
+  if (!t.context)
+    throw new Error("Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.");
+  const o = {}, s = {
+    context: t.context,
+    event: n.event,
+    spawn: _r(e, t, n.event, o),
+    self: e.self,
+    system: e.system
+  };
+  let a = {};
+  if (typeof i == "function")
+    a = i(s, r);
+  else
+    for (const u of Object.keys(i)) {
+      const f = i[u];
+      a[u] = typeof f == "function" ? f(s, r) : f;
+    }
+  const c = Object.assign({}, t.context, a);
+  return [V(t, {
+    context: c,
+    children: Object.keys(o).length ? {
+      ...t.children,
+      ...o
+    } : t.children
+  }), void 0, void 0];
+}
+function O(e) {
+  function t(n, r) {
+  }
+  return t.type = "xstate.assign", t.assignment = e, t.resolve = br, t;
+}
+const Tt = /* @__PURE__ */ new WeakMap();
+function Y(e, t, n) {
+  let r = Tt.get(e);
+  return r ? t in r || (r[t] = n()) : (r = {
+    [t]: n()
+  }, Tt.set(e, r)), r[t];
+}
+const Tr = {}, ne = (e) => typeof e == "string" ? {
+  type: e
+} : typeof e == "function" ? "resolve" in e ? {
+  type: e.type
+} : {
+  type: e.name
+} : e;
+class Ne {
+  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(Yt), 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 ? ht(this.config.states, (r, i) => new Ne(r, {
+      _parent: this,
+      _key: i,
+      _machine: this.machine
+    })) : Tr, 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 = q(this.config.entry).slice(), this.exit = q(this.config.exit).slice(), this.meta = this.config.meta, this.output = this.type === "final" || !this.parent ? this.config.output : void 0, this.tags = q(t.tags).slice();
+  }
+  /** @internal */
+  _initialize() {
+    this.transitions = Kn(this), this.config.always && (this.always = Z(this.config.always).map((t) => W(this, Zt, 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(ne),
+        eventType: null,
+        reenter: !1,
+        toJSON: () => ({
+          target: this.initial.target.map((t) => `#${t.id}`),
+          source: `#${this.id}`,
+          actions: this.initial.actions.map(ne),
+          eventType: null
+        })
+      } : void 0,
+      history: this.history,
+      states: ht(this.states, (t) => t.definition),
+      on: this.on,
+      transitions: [...this.transitions.values()].flat().map((t) => ({
+        ...t,
+        actions: t.actions.map(ne)
+      })),
+      entry: this.entry.map(ne),
+      exit: this.exit.map(ne),
+      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 Y(this, "invoke", () => q(this.config.invoke).map((t, n) => {
+      const {
+        src: r,
+        systemId: i
+      } = t, o = t.id ?? pt(this.id, n), s = typeof r == "string" ? r : `xstate.invoke.${pt(this.id, n)}`;
+      return {
+        ...t,
+        src: s,
+        id: o,
+        systemId: i,
+        toJSON() {
+          const {
+            onDone: a,
+            onError: c,
+            ...u
+          } = t;
+          return {
+            ...u,
+            type: "xstate.invoke",
+            src: s,
+            id: o
+          };
+        }
+      };
+    }));
+  }
+  /** The mapping of events to transitions. */
+  get on() {
+    return Y(this, "on", () => [...this.transitions].flatMap(([n, r]) => r.map((i) => [n, i])).reduce((n, [r, i]) => (n[r] = n[r] || [], n[r].push(i), n), {}));
+  }
+  get after() {
+    return Y(this, "delayedTransitions", () => Vn(this));
+  }
+  get initial() {
+    return Y(this, "initial", () => zn(this, this.config.initial));
+  }
+  /** @internal */
+  next(t, n) {
+    const r = n.type, i = [];
+    let o;
+    const s = Y(this, `candidates-${r}`, () => Bn(this, r));
+    for (const a of s) {
+      const {
+        guard: c
+      } = a, u = t.context;
+      let f = !1;
+      try {
+        f = !c || Re(c, u, n, t);
+      } catch (l) {
+        const d = typeof c == "string" ? c : typeof c == "object" ? c.type : void 0;
+        throw new Error(`Unable to evaluate guard ${d ? `'${d}' ` : ""}in transition for event '${r}' in state node '${this.id}':
+${l.message}`);
+      }
+      if (f) {
+        i.push(...a.actions), o = a;
+        break;
+      }
+    }
+    return o ? [o] : void 0;
+  }
+  /** All the event types accepted by this state node and its descendants. */
+  get events() {
+    return Y(this, "events", () => {
+      const {
+        states: t
+      } = this, n = new Set(this.ownEvents);
+      if (t)
+        for (const r of Object.keys(t)) {
+          const i = t[r];
+          if (i.states)
+            for (const o of i.events)
+              n.add(`${o}`);
+        }
+      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((r) => !(!r.target && !r.actions.length && !r.reenter))));
+    return Array.from(t);
+  }
+}
+const Ir = "#";
+class ut {
+  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?.actors ?? {},
+      actions: n?.actions ?? {},
+      delays: n?.delays ?? {},
+      guards: 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 Ne(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: r,
+      actors: i,
+      delays: o
+    } = this.implementations;
+    return new ut(this.config, {
+      actions: {
+        ...n,
+        ...t.actions
+      },
+      guards: {
+        ...r,
+        ...t.guards
+      },
+      actors: {
+        ...i,
+        ...t.actors
+      },
+      delays: {
+        ...o,
+        ...t.delays
+      }
+    });
+  }
+  resolveState(t) {
+    const n = cr(this.root, t.value), r = Ee(Oe(this.root, n));
+    return Me({
+      _nodes: [...r],
+      context: t.context || {},
+      children: {},
+      status: it(r, 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, r) {
+    return Ke(t, n, r, []).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, r) {
+    return Ke(t, n, r, []).microstates;
+  }
+  getTransitionData(t, n) {
+    return ot(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, r) {
+    const {
+      context: i
+    } = this.config, o = Me({
+      context: typeof i != "function" && i ? i : {},
+      _nodes: [this.root],
+      children: {},
+      status: "active"
+    }, this);
+    return typeof i == "function" ? ee(o, n, t, [O(({
+      spawn: a,
+      event: c,
+      self: u
+    }) => i({
+      spawn: a,
+      input: c.input,
+      self: u
+    }))], r, void 0) : o;
+  }
+  /**
+   * Returns the initial `State` instance, with reference to `self` as an
+   * `ActorRef`.
+   */
+  getInitialSnapshot(t, n) {
+    const r = $t(n), i = [], o = this.getPreInitialState(t, r, i), s = Xe([{
+      target: [...un(this.root)],
+      source: this.root,
+      reenter: !0,
+      actions: [],
+      eventType: null,
+      toJSON: null
+      // TODO: fix
+    }], o, t, r, !0, i), {
+      snapshot: a
+    } = Ke(s, r, t, i);
+    return a;
+  }
+  start(t) {
+    Object.values(t.children).forEach((n) => {
+      n.getSnapshot().status === "active" && n.start();
+    });
+  }
+  getStateNodeById(t) {
+    const n = $e(t), r = n.slice(1), i = je(n[0]) ? n[0].slice(Ir.length) : n[0], o = this.idMap.get(i);
+    if (!o)
+      throw new Error(`Child state node '#${i}' does not exist on machine '${this.id}'`);
+    return Fe(o, r);
+  }
+  get definition() {
+    return this.root.definition;
+  }
+  toJSON() {
+    return this.definition;
+  }
+  getPersistedSnapshot(t, n) {
+    return mr(t, n);
+  }
+  restoreSnapshot(t, n) {
+    const r = {}, i = t.children;
+    Object.keys(i).forEach((l) => {
+      const d = i[l], p = d.snapshot, v = d.src, y = typeof v == "string" ? et(this, v) : v;
+      if (!y)
+        return;
+      const I = Ae(y, {
+        id: l,
+        parent: n.self,
+        syncSnapshot: d.syncSnapshot,
+        snapshot: p,
+        src: v,
+        systemId: d.systemId
+      });
+      r[l] = I;
+    });
+    function o(l, d) {
+      if (d instanceof Ne)
+        return d;
+      try {
+        return l.machine.getStateNodeById(d.id);
+      } catch {
+      }
+    }
+    function s(l, d) {
+      if (!d || typeof d != "object")
+        return {};
+      const p = {};
+      for (const v in d) {
+        const y = d[v];
+        for (const I of y) {
+          const N = o(l, I);
+          N && (p[v] ??= [], p[v].push(N));
+        }
+      }
+      return p;
+    }
+    const a = s(this.root, t.historyValue), c = Me({
+      ...t,
+      children: r,
+      _nodes: Array.from(Ee(Oe(this.root, t.value))),
+      historyValue: a
+    }, this), u = /* @__PURE__ */ new Set();
+    function f(l, d) {
+      if (!u.has(l)) {
+        u.add(l);
+        for (const p in l) {
+          const v = l[p];
+          if (v && typeof v == "object") {
+            if ("xstate$$type" in v && v.xstate$$type === tt) {
+              l[p] = d[v.id];
+              continue;
+            }
+            f(v, d);
+          }
+        }
+      }
+    }
+    return f(c.context, r), c;
+  }
+}
+function wr(e, t, n, r, {
+  event: i
+}) {
+  const o = typeof i == "function" ? i(n, r) : i;
+  return [t, {
+    event: o
+  }, void 0];
+}
+function kr(e, {
+  event: t
+}) {
+  e.defer(() => e.emit(t));
+}
+function mn(e) {
+  function t(n, r) {
+  }
+  return t.type = "xstate.emit", t.event = e, t.resolve = wr, t.execute = kr, t;
+}
+let Qe = /* @__PURE__ */ (function(e) {
+  return e.Parent = "#_parent", e.Internal = "#_internal", e;
+})({});
+function Pr(e, t, n, r, {
+  to: i,
+  event: o,
+  id: s,
+  delay: a
+}, c) {
+  const u = t.machine.implementations.delays;
+  if (typeof o == "string")
+    throw new Error(
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Only event objects may be used with sendTo; use sendTo({ type: "${o}" }) instead`
+    );
+  const f = typeof o == "function" ? o(n, r) : o;
+  let l;
+  if (typeof a == "string") {
+    const v = u && u[a];
+    l = typeof v == "function" ? v(n, r) : v;
+  } else
+    l = typeof a == "function" ? a(n, r) : a;
+  const d = typeof i == "function" ? i(n, r) : i;
+  let p;
+  if (typeof d == "string") {
+    if (d === Qe.Parent ? p = e.self._parent : d === Qe.Internal ? p = e.self : d.startsWith("#_") ? p = t.children[d.slice(2)] : p = c.deferredActorIds?.includes(d) ? d : t.children[d], !p)
+      throw new Error(`Unable to send event to actor '${d}' from machine '${t.machine.id}'.`);
+  } else
+    p = d || e.self;
+  return [t, {
+    to: p,
+    targetId: typeof d == "string" ? d : void 0,
+    event: f,
+    id: s,
+    delay: l
+  }, void 0];
+}
+function Dr(e, t, n) {
+  typeof n.to == "string" && (n.to = t.children[n.to]);
+}
+function Mr(e, t) {
+  e.defer(() => {
+    const {
+      to: n,
+      event: r,
+      delay: i,
+      id: o
+    } = t;
+    if (typeof i == "number") {
+      e.system.scheduler.schedule(e.self, n, r, i, o);
+      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,
+      r.type === Mn ? Qt(e.self.id, r.data) : r
+    );
+  });
+}
+function Ge(e, t, n) {
+  function r(i, o) {
+  }
+  return r.type = "xstate.sendTo", r.to = e, r.event = t, r.id = n?.id, r.delay = n?.delay, r.resolve = Pr, r.retryResolve = Dr, r.execute = Mr, r;
+}
+function Ar(e, t) {
+  return Ge(Qe.Parent, e, t);
+}
+function Er(e, t, n, r, {
+  collect: i
+}) {
+  const o = [], s = function(c) {
+    o.push(c);
+  };
+  return s.assign = (...a) => {
+    o.push(O(...a));
+  }, s.cancel = (...a) => {
+    o.push(nt(...a));
+  }, s.raise = (...a) => {
+    o.push(ct(...a));
+  }, s.sendTo = (...a) => {
+    o.push(Ge(...a));
+  }, s.sendParent = (...a) => {
+    o.push(Ar(...a));
+  }, s.spawnChild = (...a) => {
+    o.push(rt(...a));
+  }, s.stopChild = (...a) => {
+    o.push(Ce(...a));
+  }, s.emit = (...a) => {
+    o.push(mn(...a));
+  }, i({
+    context: n.context,
+    event: n.event,
+    enqueue: s,
+    check: (a) => Re(a, t.context, n.event, t),
+    self: e.self,
+    system: e.system
+  }, r), [t, void 0, o];
+}
+function Fr(e) {
+  function t(n, r) {
+  }
+  return t.type = "xstate.enqueueActions", t.collect = e, t.resolve = Er, t;
+}
+function Or(e, t, n, r, {
+  value: i,
+  label: o
+}) {
+  return [t, {
+    value: typeof i == "function" ? i(n, r) : i,
+    label: o
+  }, void 0];
+}
+function Nr({
+  logger: e
+}, {
+  value: t,
+  label: n
+}) {
+  n ? e(n, t) : e(t);
+}
+function Cr(e = ({
+  context: n,
+  event: r
+}) => ({
+  context: n,
+  event: r
+}), t) {
+  function n(r, i) {
+  }
+  return n.type = "xstate.log", n.value = e, n.label = t, n.resolve = Or, n.execute = Nr, n;
+}
+function Rr(e, t) {
+  return new ut(e, t);
+}
+function gn({
+  schemas: e,
+  actors: t,
+  actions: n,
+  guards: r,
+  delays: i
+}) {
+  return {
+    assign: O,
+    sendTo: Ge,
+    raise: ct,
+    log: Cr,
+    cancel: nt,
+    stopChild: Ce,
+    enqueueActions: Fr,
+    emit: mn,
+    spawnChild: rt,
+    createStateConfig: (o) => o,
+    createAction: (o) => o,
+    createMachine: (o) => Rr({
+      ...o,
+      schemas: e
+    }, {
+      actors: t,
+      actions: n,
+      guards: r,
+      delays: i
+    }),
+    extend: (o) => gn({
+      schemas: e,
+      actors: t,
+      actions: {
+        ...n,
+        ...o.actions
+      },
+      guards: {
+        ...r,
+        ...o.guards
+      },
+      delays: {
+        ...i,
+        ...o.delays
+      }
+    })
+  };
+}
+var F = {}, re = {}, T = {}, It;
+function k() {
+  if (It) return T;
+  It = 1, Object.defineProperty(T, "__esModule", { value: !0 });
+  var e = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"];
+  function t(h) {
+    var m = h >> 4 & 15, g = h >> 0 & 15;
+    return e[m] + e[g];
+  }
+  T.toHexString = t;
+  function n(h, m, g) {
+    for (var S = typeof h == "string" ? h : h.toFixed(0); S.length < m; )
+      S = g + S;
+    return S;
+  }
+  T.padLeft = n;
+  function r(h) {
+    var m = h.split("*"), g = m[0], S = m[1], D = i(g), E = parseInt(S, 16);
+    return D === E;
+  }
+  T.validNmeaChecksum = r;
+  function i(h) {
+    for (var m = h.charCodeAt(1), g = 2; g < h.length; g += 1)
+      m = m ^ h.charCodeAt(g);
+    return m = m & 255, m;
+  }
+  T.computeNmeaChecksum = i;
+  function o(h) {
+    return "*" + t(i(h));
+  }
+  T.createNmeaChecksumFooter = o;
+  function s(h) {
+    return h + o(h);
+  }
+  T.appendChecksumFooter = s;
+  function a(h, m) {
+    return h === void 0 ? "" : h.toFixed(m);
+  }
+  T.encodeFixed = a;
+  function c(h) {
+    if (h === void 0)
+      return ",";
+    var m;
+    h < 0 ? (m = "S", h = -h) : m = "N";
+    var g = Math.floor(h), S = n(g, 2, "0"), D = h - g, E = D * 60, R = n(E.toFixed(6), 9, "0");
+    return S = S + R + "," + m, S;
+  }
+  T.encodeLatitude = c;
+  function u(h) {
+    if (h === void 0)
+      return ",";
+    var m;
+    h < 0 ? (m = "W", h = -h) : m = "E";
+    var g = Math.floor(h), S = n(g, 3, "0"), D = h - g, E = D * 60, R = n(E.toFixed(6), 9, "0");
+    return S = S + R + "," + m, S;
+  }
+  T.encodeLongitude = u;
+  function f(h) {
+    return h === void 0 ? "," : h.toFixed(1) + ",M";
+  }
+  T.encodeAltitude = f;
+  function l(h) {
+    return h === void 0 ? "" : h.toFixed(1);
+  }
+  T.encodeAltitudeNoUnits = l;
+  function d(h) {
+    return h === void 0 ? "," : h.toFixed(1) + ",M";
+  }
+  T.encodeGeoidalSeperation = d;
+  function p(h) {
+    return h === void 0 ? "" : h.toFixed(1);
+  }
+  T.encodeGeoidalSeperationNoUnits = p;
+  function v(h) {
+    return h === void 0 ? "" : n(h.toFixed(2), 6, "0");
+  }
+  T.encodeDegrees = v;
+  function y(h) {
+    if (h === void 0)
+      return "";
+    var m = h.getUTCFullYear(), g = h.getUTCMonth() + 1, S = h.getUTCDate();
+    return n(S, 2, "0") + n(g, 2, "0") + m.toFixed(0).substr(2);
+  }
+  T.encodeDate = y;
+  function I(h) {
+    if (h === void 0)
+      return "";
+    var m = h.getUTCHours(), g = h.getUTCMinutes(), S = h.getUTCSeconds();
+    return n(m, 2, "0") + n(g, 2, "0") + n(S, 2, "0");
+  }
+  T.encodeTime = I;
+  function N(h) {
+    return h === void 0 ? "" : h.toString();
+  }
+  T.encodeValue = N;
+  function C(h) {
+    return h === "" ? 0 : parseFloat(h);
+  }
+  T.parseFloatSafe = C;
+  function K(h) {
+    return h === "" ? 0 : parseInt(h, 10);
+  }
+  T.parseIntSafe = K;
+  function xe(h) {
+    if (h === void 0)
+      return "";
+    var m = parseFloat(h);
+    return m === NaN ? h : m;
+  }
+  T.parseNumberOrString = xe;
+  function te(h) {
+    var m = h.indexOf(".");
+    if (m < 0)
+      return 0;
+    var g, S;
+    return m >= 3 ? (g = h.substring(0, m - 2), S = h.substring(m - 2)) : (g = "0", S = h), parseFloat(g) + parseFloat(S) / 60;
+  }
+  T.parseDmCoordinate = te;
+  function qe(h, m) {
+    var g = m === "N" ? 1 : -1;
+    return te(h) * g;
+  }
+  T.parseLatitude = qe;
+  function Ue(h, m) {
+    var g = m === "E" ? 1 : -1;
+    return te(h) * g;
+  }
+  T.parseLongitude = Ue;
+  function He(h, m) {
+    if (h === "")
+      return /* @__PURE__ */ new Date(0);
+    var g = /* @__PURE__ */ new Date();
+    if (m) {
+      var S = m.slice(4), D = parseInt(m.slice(2, 4), 10) - 1, E = m.slice(0, 2);
+      S.length === 4 ? g.setUTCFullYear(Number(S), Number(D), Number(E)) : g.setUTCFullYear(+("20" + S), Number(D), Number(E));
+    }
+    g.setUTCHours(Number(h.slice(0, 2))), g.setUTCMinutes(Number(h.slice(2, 4))), g.setUTCSeconds(Number(h.slice(4, 6)));
+    var R = h.slice(7), z = R.length, H = 0;
+    return z !== 0 && (H = parseFloat(R) * Math.pow(10, 3 - z)), g.setUTCMilliseconds(Number(H)), g;
+  }
+  T.parseTime = He;
+  function We(h, m) {
+    var g = parseInt(h.slice(0, 2), 10), S = parseInt(h.slice(2, 4), 10), D = parseInt(h.slice(4, 6), 10);
+    D < 73 ? D = D + 2e3 : D = D + 1900;
+    var E = parseInt(m.slice(0, 2), 10), R = parseInt(m.slice(2, 4), 10), z = parseInt(m.slice(4, 6), 10), H = 0;
+    return m.length === 9 && (H = parseInt(m.slice(7, 9), 10) * 10), new Date(Date.UTC(D, S - 1, g, E, R, z, H));
+  }
+  return T.parseDatetime = We, T;
+}
+var se = {}, wt;
+function w() {
+  if (wt) return se;
+  wt = 1, Object.defineProperty(se, "__esModule", { value: !0 });
+  function e(n, r, i) {
+    return {
+      sentenceId: r,
+      talkerId: n.talkerId,
+      chxOk: n.chxOk,
+      sentenceName: i
+    };
+  }
+  se.initStubFields = e;
+  function t(n, r) {
+    var i, o;
+    return n.charAt(1) === "P" ? (i = "P", o = n.substr(2)) : (i = n.substr(1, 2), o = n.substr(3)), { talkerId: i, sentenceId: o, chxOk: r || void 0 };
+  }
+  return se.parseStub = t, se;
+}
+var kt;
+function jr() {
+  return kt || (kt = 1, (function(e) {
+    var t = re && re.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "APB", e.sentenceName = 'Autopilot sentence "B"';
+    function i(o, s) {
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { status1: s[1], status2: s[2], xteMagn: n.parseFloatSafe(s[3]), steerDir: s[4], xteUnit: s[5], arrivalCircleStatus: s[6], arrivalPerpendicularStatus: s[7], bearingOrig2Dest: n.parseFloatSafe(s[8]), bearingOrig2DestType: s[9], waypoint: s[10], bearing2Dest: n.parseFloatSafe(s[11]), bearingDestType: s[12], heading2steer: n.parseFloatSafe(s[13]), headingDestType: s[14] });
+    }
+    e.decodeSentence = i;
+  })(re)), re;
+}
+var ie = {}, Pt;
+function Gr() {
+  return Pt || (Pt = 1, (function(e) {
+    var t = ie && ie.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "BWC", e.sentenceName = "Bearing and distance to waypoint - great circle";
+    function i(o, s) {
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { time: n.parseTime(s[1]), bearingLatitude: n.parseLatitude(s[2], s[3]), bearingLongitude: n.parseLongitude(s[4], s[5]), bearingTrue: n.parseFloatSafe(s[6]), bearingMagnetic: n.parseFloatSafe(s[8]), distanceNm: n.parseFloatSafe(s[10]), waypointId: s[12], faaMode: s[13] });
+    }
+    e.decodeSentence = i;
+  })(ie)), ie;
+}
+var oe = {}, Dt;
+function Lr() {
+  return Dt || (Dt = 1, (function(e) {
+    var t = oe && oe.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "DBT", e.sentenceName = "Depth below transducer";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { depthFeet: n.parseFloatSafe(a[1]), depthMeters: n.parseFloatSafe(a[3]), depthFathoms: n.parseFloatSafe(a[5]) });
+    }
+    e.decodeSentence = i;
+    function o(s, a) {
+      var c = ["$" + a + e.sentenceId];
+      c.push(n.encodeFixed(s.depthFeet, 2)), c.push("f"), c.push(n.encodeFixed(s.depthMeters, 2)), c.push("M"), c.push(n.encodeFixed(s.depthFathoms, 2)), c.push("F");
+      var u = c.join(",");
+      return u + n.createNmeaChecksumFooter(u);
+    }
+    e.encodePacket = o;
+  })(oe)), oe;
+}
+var ae = {}, Mt;
+function xr() {
+  return Mt || (Mt = 1, (function(e) {
+    var t = ae && ae.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "DTM", e.sentenceName = "Datum reference";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { datumCode: o(a[1]), datumSubcode: a[2] || void 0, offsetLatitude: n.parseLatitude(a[3], a[4]), offsetLongitude: n.parseLongitude(a[5], a[6]), offsetAltitudeMeters: n.parseFloatSafe(a[7]), datumName: o(a[8]) });
+    }
+    e.decodeSentence = i;
+    function o(s) {
+      return s === "W84" ? "W84" : s === "W72" ? "W72" : s === "S85" ? "S85" : s === "P90" ? "P90" : s === "999" ? "999" : "";
+    }
+  })(ae)), ae;
+}
+var ce = {}, At;
+function qr() {
+  return At || (At = 1, (function(e) {
+    var t = ce && ce.__assign || function() {
+      return t = Object.assign || function(a) {
+        for (var c, u = 1, f = arguments.length; u < f; u++) {
+          c = arguments[u];
+          for (var l in c) Object.prototype.hasOwnProperty.call(c, l) && (a[l] = c[l]);
+        }
+        return a;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "GGA", e.sentenceName = "Global positioning system fix data";
+    var i = ["none", "fix", "delta", "pps", "rtk", "frtk", "estimated", "manual", "simulation"];
+    function o(a, c) {
+      return t(t({}, r.initStubFields(a, e.sentenceId, e.sentenceName)), { time: n.parseTime(c[1]), latitude: n.parseLatitude(c[2], c[3]), longitude: n.parseLongitude(c[4], c[5]), fixType: i[n.parseIntSafe(c[6])], satellitesInView: n.parseIntSafe(c[7]), horizontalDilution: n.parseFloatSafe(c[8]), altitudeMeters: n.parseFloatSafe(c[9]), geoidalSeperation: n.parseFloatSafe(c[11]), differentialAge: n.parseFloatSafe(c[13]), differentialRefStn: c[14] });
+    }
+    e.decodeSentence = o;
+    function s(a, c) {
+      var u = ["$" + c + e.sentenceId];
+      u.push(n.encodeTime(a.time)), u.push(n.encodeLatitude(a.latitude)), u.push(n.encodeLongitude(a.longitude)), u.push(n.encodeValue(i.indexOf(a.fixType))), u.push(n.encodeValue(a.satellitesInView)), u.push(n.encodeFixed(a.horizontalDilution, 1)), u.push(n.encodeAltitude(a.altitudeMeters)), u.push(n.encodeGeoidalSeperation(a.geoidalSeperation)), u.push(n.encodeFixed(a.differentialAge, 2)), u.push(n.encodeValue(a.differentialRefStn));
+      var f = u.join(",");
+      return f + n.createNmeaChecksumFooter(f);
+    }
+    e.encodePacket = s;
+  })(ce)), ce;
+}
+var ue = {}, Et;
+function Ur() {
+  return Et || (Et = 1, (function(e) {
+    var t = ue && ue.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "GLL", e.sentenceName = "Geographic position - latitude and longitude";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { latitude: n.parseLatitude(a[1], a[2]), longitude: n.parseLongitude(a[3], a[4]), time: n.parseTime(a[5]), status: a[6] === "A" ? "valid" : "invalid", faaMode: a[7] });
+    }
+    e.decodeSentence = i;
+    function o(s, a) {
+      var c = ["$" + a + e.sentenceId];
+      c.push(n.encodeLatitude(s.latitude)), c.push(n.encodeLongitude(s.longitude)), c.push(n.encodeTime(s.time)), c.push(s.status === "valid" ? "A" : "V"), s.faaMode && c.push(s.faaMode);
+      var u = c.join(",");
+      return u + n.createNmeaChecksumFooter(u);
+    }
+    e.encodePacket = o;
+  })(ue)), ue;
+}
+var de = {}, Ft;
+function Hr() {
+  return Ft || (Ft = 1, (function(e) {
+    var t = de && de.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "GNS", e.sentenceName = "GNSS fix data";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { time: n.parseTime(a[1]), latitude: n.parseLatitude(a[2], a[3]), longitude: n.parseLongitude(a[4], a[5]), modeIndicator: a[6], satellitesInView: n.parseIntSafe(a[7]), horizontalDilution: n.parseFloatSafe(a[8]), altitudeMeters: n.parseFloatSafe(a[9]), geoidalSeperation: n.parseFloatSafe(a[10]), differentialAge: n.parseFloatSafe(a[11]), differentialRefStn: a[12] });
+    }
+    e.decodeSentence = i;
+    function o(s, a) {
+      var c = ["$" + a + e.sentenceId];
+      c.push(n.encodeTime(s.time)), c.push(n.encodeLatitude(s.latitude)), c.push(n.encodeLongitude(s.longitude)), c.push(s.modeIndicator), c.push(n.encodeValue(s.satellitesInView)), c.push(n.encodeFixed(s.horizontalDilution, 1)), c.push(n.encodeAltitudeNoUnits(s.altitudeMeters)), c.push(n.encodeGeoidalSeperationNoUnits(s.geoidalSeperation)), c.push(n.encodeFixed(s.differentialAge, 2)), c.push(n.encodeValue(s.differentialRefStn));
+      var u = c.join(",");
+      return u + n.createNmeaChecksumFooter(u);
+    }
+    e.encodePacket = o;
+  })(de)), de;
+}
+var fe = {}, Ot;
+function Wr() {
+  return Ot || (Ot = 1, (function(e) {
+    var t = fe && fe.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "GSA", e.sentenceName = "Active satellites and dilution of precision";
+    var i = ["unknown", "none", "2D", "3D"];
+    function o(s, a) {
+      for (var c = [], u = 3; u < 15; u++)
+        a[u] && c.push(+a[u]);
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { selectionMode: a[1] === "A" ? "automatic" : "manual", fixMode: i[n.parseIntSafe(a[2])], satellites: c, PDOP: n.parseFloatSafe(a[15]), HDOP: n.parseFloatSafe(a[16]), VDOP: n.parseFloatSafe(a[17]) });
+    }
+    e.decodeSentence = o;
+  })(fe)), fe;
+}
+var le = {}, Nt;
+function Br() {
+  return Nt || (Nt = 1, (function(e) {
+    var t = le && le.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "GST", e.sentenceName = "GPS pseudorange noise statistics";
+    function i(o, s) {
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { time: n.parseTime(s[1]), totalRms: n.parseFloatSafe(s[2]), semiMajorError: n.parseFloatSafe(s[3]), semiMinorError: n.parseFloatSafe(s[4]), orientationOfSemiMajorError: n.parseFloatSafe(s[5]), latitudeError: n.parseFloatSafe(s[6]), longitudeError: n.parseFloatSafe(s[7]), altitudeError: n.parseFloatSafe(s[8]) });
+    }
+    e.decodeSentence = i;
+  })(le)), le;
+}
+var he = {}, Ct;
+function Vr() {
+  return Ct || (Ct = 1, (function(e) {
+    var t = he && he.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "GSV", e.sentenceName = "Satellites in view";
+    function i(o, s) {
+      for (var a = (s.length - 4) / 4, c = [], u = 0; u < a; u++) {
+        var f = u * 4 + 4;
+        c.push({
+          prnNumber: n.parseIntSafe(s[f]),
+          elevationDegrees: n.parseIntSafe(s[f + 1]),
+          azimuthTrue: n.parseIntSafe(s[f + 2]),
+          SNRdB: n.parseIntSafe(s[f + 3])
+        });
+      }
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { numberOfMessages: n.parseIntSafe(s[1]), messageNumber: n.parseIntSafe(s[2]), satellitesInView: n.parseIntSafe(s[3]), satellites: c });
+    }
+    e.decodeSentence = i;
+  })(he)), he;
+}
+var pe = {}, Rt;
+function Kr() {
+  return Rt || (Rt = 1, (function(e) {
+    var t = pe && pe.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "HDG", e.sentenceName = "Heading - deviation and variation";
+    function i(o, s) {
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { heading: n.parseFloatSafe(s[1]), deviation: n.parseFloatSafe(s[2]), deviationDirection: s[3] === "E" ? "E" : s[3] === "W" ? "W" : "", variation: n.parseFloatSafe(s[4]), variationDirection: s[5] === "E" ? "E" : s[5] === "W" ? "W" : "" });
+    }
+    e.decodeSentence = i;
+  })(pe)), pe;
+}
+var ve = {}, jt;
+function zr() {
+  return jt || (jt = 1, (function(e) {
+    var t = ve && ve.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "HDM", e.sentenceName = "Heading - magnetic";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { heading: n.parseFloatSafe(a[1]) });
+    }
+    e.decodeSentence = i;
+    function o(s, a) {
+      var c = ["$" + a + e.sentenceId];
+      c.push(n.encodeFixed(s.heading, 1)), c.push("M");
+      var u = c.join(",");
+      return u + n.createNmeaChecksumFooter(u);
+    }
+    e.encodePacket = o;
+  })(ve)), ve;
+}
+var me = {}, Gt;
+function Jr() {
+  return Gt || (Gt = 1, (function(e) {
+    var t = me && me.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "HDT", e.sentenceName = "Heading - true";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { heading: n.parseFloatSafe(a[1]) });
+    }
+    e.decodeSentence = i;
+    function o(s, a) {
+      var c = ["$" + a + e.sentenceId];
+      c.push(n.encodeFixed(s.heading, 1)), c.push("T");
+      var u = c.join(",");
+      return u + n.createNmeaChecksumFooter(u);
+    }
+    e.encodePacket = o;
+  })(me)), me;
+}
+var ge = {}, Lt;
+function Yr() {
+  return Lt || (Lt = 1, (function(e) {
+    var t = ge && ge.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "MTK", e.sentenceName = "Configuration packet";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { packetType: n.parseIntSafe(s.sentenceId.substr(3)), data: a.slice(1).map(n.parseNumberOrString) });
+    }
+    e.decodeSentence = i;
+    function o(s, a) {
+      var c = ["$" + a + e.sentenceId + n.padLeft(s.packetType, 3, "0")];
+      c = c.concat(s.data.toString());
+      var u = c.join(",");
+      return u + n.createNmeaChecksumFooter(u);
+    }
+    e.encodePacket = o;
+  })(ge)), ge;
+}
+var ye = {}, xt;
+function Zr() {
+  return xt || (xt = 1, (function(e) {
+    var t = ye && ye.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "MWV", e.sentenceName = "Wind speed and angle";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { windAngle: n.parseFloatSafe(a[1]), reference: a[2] === "R" ? "relative" : "true", speed: n.parseFloatSafe(a[3]), units: a[4] === "K" ? "K" : a[4] === "M" ? "M" : "N", status: a[5] === "A" ? "valid" : "invalid" });
+    }
+    e.decodeSentence = i;
+    function o(s, a) {
+      var c = ["$" + a + e.sentenceId];
+      c.push(n.encodeDegrees(s.windAngle)), c.push(s.reference === "relative" ? "R" : "T"), c.push(n.encodeFixed(s.speed, 2)), c.push(s.units === "K" ? "K" : s.units === "M" ? "M" : "N"), c.push(s.status === "valid" ? "A" : "V");
+      var u = c.join(",");
+      return u + n.createNmeaChecksumFooter(u);
+    }
+    e.encodePacket = o;
+  })(ye)), ye;
+}
+var Se = {}, qt;
+function Xr() {
+  return qt || (qt = 1, (function(e) {
+    var t = Se && Se.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "RDID", e.sentenceName = "RDI proprietary heading, pitch, and roll";
+    function i(o, s) {
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { roll: n.parseFloatSafe(s[1]), pitch: n.parseFloatSafe(s[2]), heading: n.parseFloatSafe(s[3]) });
+    }
+    e.decodeSentence = i;
+  })(Se)), Se;
+}
+var _e = {}, Ut;
+function Qr() {
+  return Ut || (Ut = 1, (function(e) {
+    var t = _e && _e.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "RMC", e.sentenceName = "Recommended minimum navigation information";
+    function i(o, s) {
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { datetime: n.parseDatetime(s[9], s[1]), status: s[2] === "A" ? "valid" : "warning", latitude: n.parseLatitude(s[3], s[4]), longitude: n.parseLongitude(s[5], s[6]), speedKnots: n.parseFloatSafe(s[7]), trackTrue: n.parseFloatSafe(s[8]), variation: n.parseFloatSafe(s[10]), variationPole: s[11] === "E" ? "E" : s[11] === "W" ? "W" : "", faaMode: s[12] });
+    }
+    e.decodeSentence = i;
+  })(_e)), _e;
+}
+var be = {}, Ht;
+function $r() {
+  return Ht || (Ht = 1, (function(e) {
+    var t = be && be.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "VHW", e.sentenceName = "Water speed and heading";
+    function i(o, s) {
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { degreesTrue: n.parseFloatSafe(s[1]), degreesMagnetic: n.parseFloatSafe(s[3]), speedKnots: n.parseFloatSafe(s[5]), speedKmph: n.parseFloatSafe(s[7]) });
+    }
+    e.decodeSentence = i;
+  })(be)), be;
+}
+var Te = {}, Wt;
+function es() {
+  return Wt || (Wt = 1, (function(e) {
+    var t = Te && Te.__assign || function() {
+      return t = Object.assign || function(s) {
+        for (var a, c = 1, u = arguments.length; c < u; c++) {
+          a = arguments[c];
+          for (var f in a) Object.prototype.hasOwnProperty.call(a, f) && (s[f] = a[f]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "VTG", e.sentenceName = "Track made good and ground speed";
+    function i(s, a) {
+      return t(t({}, r.initStubFields(s, e.sentenceId, e.sentenceName)), { trackTrue: n.parseFloatSafe(a[1]), trackMagnetic: n.parseFloatSafe(a[3]), speedKnots: n.parseFloatSafe(a[5]), speedKmph: n.parseFloatSafe(a[7]), faaMode: a[9] });
+    }
+    e.decodeSentence = i;
+    function o(s, a) {
+      var c = ["$" + a + e.sentenceId];
+      c.push(n.encodeDegrees(s.trackTrue)), c.push("T"), c.push(n.encodeDegrees(s.trackMagnetic)), c.push("M"), c.push(n.encodeFixed(s.speedKnots, 2)), c.push("N"), s.speedKmph ? (c.push(n.encodeFixed(s.speedKmph, 2)), c.push("K")) : (c.push(""), c.push("")), s.faaMode && c.push(s.faaMode);
+      var u = c.join(",");
+      return u + n.createNmeaChecksumFooter(u);
+    }
+    e.encodePacket = o;
+  })(Te)), Te;
+}
+var Ie = {}, Bt;
+function ts() {
+  return Bt || (Bt = 1, (function(e) {
+    var t = Ie && Ie.__assign || function() {
+      return t = Object.assign || function(o) {
+        for (var s, a = 1, c = arguments.length; a < c; a++) {
+          s = arguments[a];
+          for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (o[u] = s[u]);
+        }
+        return o;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = k(), r = w();
+    e.sentenceId = "ZDA", e.sentenceName = "UTC, day, month, year, and local time zone";
+    function i(o, s) {
+      return t(t({}, r.initStubFields(o, e.sentenceId, e.sentenceName)), { datetime: n.parseTime(s[1], s.slice(2, 5).join("")), localZoneHours: n.parseIntSafe(s[5]), localZoneMinutes: n.parseIntSafe(s[6]) });
+    }
+    e.decodeSentence = i;
+  })(Ie)), Ie;
+}
+var we = {}, Vt;
+function yn() {
+  return Vt || (Vt = 1, (function(e) {
+    var t = we && we.__assign || function() {
+      return t = Object.assign || function(i) {
+        for (var o, s = 1, a = arguments.length; s < a; s++) {
+          o = arguments[s];
+          for (var c in o) Object.prototype.hasOwnProperty.call(o, c) && (i[c] = o[c]);
+        }
+        return i;
+      }, t.apply(this, arguments);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var n = w();
+    e.sentenceId = "?";
+    function r(i, o) {
+      return t(t({}, n.initStubFields(i, e.sentenceId)), { originalPacketId: i.sentenceId, dataFields: o.slice(1) });
+    }
+    e.decodeSentence = r;
+  })(we)), we;
+}
+var Kt;
+function ns() {
+  if (Kt) return F;
+  Kt = 1;
+  var e = F && F.__extends || /* @__PURE__ */ (function() {
+    var _ = function(b, P) {
+      return _ = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(M, x) {
+        M.__proto__ = x;
+      } || function(M, x) {
+        for (var J in x) x.hasOwnProperty(J) && (M[J] = x[J]);
+      }, _(b, P);
+    };
+    return function(b, P) {
+      _(b, P);
+      function M() {
+        this.constructor = b;
+      }
+      b.prototype = P === null ? Object.create(P) : (M.prototype = P.prototype, new M());
+    };
+  })();
+  Object.defineProperty(F, "__esModule", { value: !0 });
+  var t = jr(), n = Gr(), r = Lr(), i = xr(), o = qr(), s = Ur(), a = Hr(), c = Wr(), u = Br(), f = Vr(), l = Kr(), d = zr(), p = Jr(), v = Yr(), y = Zr(), I = Xr(), N = Qr(), C = $r(), K = es(), xe = ts(), te = w(), qe = yn(), Ue = k(), He = {
+    APB: t.decodeSentence,
+    BWC: n.decodeSentence,
+    DBT: r.decodeSentence,
+    DTM: i.decodeSentence,
+    GGA: o.decodeSentence,
+    GLL: s.decodeSentence,
+    GNS: a.decodeSentence,
+    GSA: c.decodeSentence,
+    GST: u.decodeSentence,
+    GSV: f.decodeSentence,
+    HDG: l.decodeSentence,
+    HDM: d.decodeSentence,
+    HDT: p.decodeSentence,
+    MTK: v.decodeSentence,
+    MWV: y.decodeSentence,
+    RDID: I.decodeSentence,
+    RMC: N.decodeSentence,
+    VHW: C.decodeSentence,
+    VTG: K.decodeSentence,
+    ZDA: xe.decodeSentence
+  }, We = {
+    DBT: r.encodePacket,
+    GGA: o.encodePacket,
+    GLL: s.encodePacket,
+    GNS: a.encodePacket,
+    HDM: d.encodePacket,
+    HDT: p.encodePacket,
+    MTK: v.encodePacket,
+    MWV: y.encodePacket,
+    VTG: K.encodePacket
+  }, h = (
+    /** @class */
+    (function() {
+      function _(b) {
+        b === void 0 && (b = !1), this.ableToParseBadChecksum = b;
+      }
+      return _.getParser = function(b) {
+        return b.sentenceId.substr(0, 3) === "MTK" ? v.decodeSentence : He[b.sentenceId];
+      }, _.prototype.assemble = function(b, P) {
+        var M = _.getParser(b);
+        return M ? M(b, P) : this.assembleCustomPacket(b, P);
+      }, _.prototype.assembleCustomPacket = function(b, P) {
+        return null;
+      }, _;
+    })()
+  );
+  F.DefaultPacketFactory = h;
+  var m = new h();
+  function g(_, b) {
+    var P = !0;
+    if (!Ue.validNmeaChecksum(_)) {
+      if (!b.ableToParseBadChecksum)
+        throw Error('Invalid sentence: "' + _ + '".');
+      P = !1;
+    }
+    var M = _.split("*")[0].split(","), x = te.parseStub(M[0], P), J = b.assemble(x, M);
+    if (!J)
+      throw Error('No known parser for sentence ID "' + x.sentenceId + '".');
+    return J;
+  }
+  F.parseGenericPacket = g;
+  function S(_) {
+    return g(_, m);
+  }
+  F.parseNmeaSentence = S;
+  function D(_, b) {
+    if (b === void 0 && (b = "P"), _ === void 0)
+      throw new Error("Packet must be given.");
+    var P = We[_.sentenceId];
+    if (P)
+      return P(_, b);
+    throw Error('No known encoder for sentence ID "' + _.sentenceId + '"');
+  }
+  F.encodeNmeaPacket = D;
+  var E = (
+    /** @class */
+    (function(_) {
+      e(b, _);
+      function b() {
+        return _.call(this, !0) || this;
+      }
+      return b.prototype.assembleCustomPacket = function(P, M) {
+        return qe.decodeSentence(P, M);
+      }, b;
+    })(h)
+  );
+  F.UnsafePacketFactory = E;
+  var R = new E();
+  function z(_) {
+    return g(_, R);
+  }
+  F.parseUnsafeNmeaSentence = z;
+  function H(_) {
+    return _.sentenceId === "?" ? _.originalPacketId : _.sentenceId;
+  }
+  return F.getUnsafePacketId = H, F;
+}
+var Le = ns(), rs = yn(), dt = w();
+const zt = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"];
+function ss(e) {
+  const t = e >> 4 & 15, n = e >> 0 & 15;
+  return zt[t] + zt[n];
+}
+function G(e, t, n) {
+  let r = typeof e == "string" ? e : e.toFixed(0);
+  for (; r.length < t; )
+    r = n + r;
+  return r;
+}
+function Ls(e) {
+  const [t, n] = e.split("*"), r = Sn(t), i = Number.parseInt(n, 16);
+  return r === i;
+}
+function Sn(e) {
+  let t = e.charCodeAt(1);
+  for (let n = 2; n < e.length; n += 1)
+    t = t ^ e.charCodeAt(n);
+  return t = t & 255, t;
+}
+function is(e) {
+  return `*${ss(Sn(e))}`;
+}
+function xs(e) {
+  return e + is(e);
+}
+function qs(e, t) {
+  return e === void 0 ? "" : e.toFixed(t);
+}
+function Us(e) {
+  if (e === void 0)
+    return ",";
+  let t;
+  e < 0 ? (t = "S", e = -e) : t = "N";
+  const n = Math.floor(e);
+  let r = G(n, 2, "0");
+  const o = (e - n) * 60, s = G(o.toFixed(6), 9, "0");
+  return r = `${r + s},${t}`, r;
+}
+function Hs(e) {
+  if (e === void 0)
+    return ",";
+  let t;
+  e < 0 ? (t = "W", e = -e) : t = "E";
+  const n = Math.floor(e);
+  let r = G(n, 3, "0");
+  const o = (e - n) * 60, s = G(o.toFixed(6), 9, "0");
+  return r = `${r + s},${t}`, r;
+}
+function Ws(e) {
+  return e === void 0 ? "," : `${e.toFixed(1)},M`;
+}
+function Bs(e) {
+  return e === void 0 ? "" : e.toFixed(1);
+}
+function Vs(e) {
+  return e === void 0 ? "," : `${e.toFixed(1)},M`;
+}
+function Ks(e) {
+  return e === void 0 ? "" : e.toFixed(1);
+}
+function zs(e) {
+  return e === void 0 ? "" : G(e.toFixed(2), 6, "0");
+}
+function Js(e) {
+  if (e === void 0)
+    return "";
+  const t = e.getUTCFullYear(), n = e.getUTCMonth() + 1, r = e.getUTCDate();
+  return G(r, 2, "0") + G(n, 2, "0") + t.toFixed(0).substr(2);
+}
+function Ys(e) {
+  if (e === void 0)
+    return "";
+  const t = e.getUTCHours(), n = e.getUTCMinutes(), r = e.getUTCSeconds();
+  return G(t, 2, "0") + G(n, 2, "0") + G(r, 2, "0");
+}
+function Zs(e) {
+  return e === void 0 ? "" : String(e);
+}
+function L(e) {
+  return e === "" ? 0 : Number.parseFloat(e);
+}
+function Xs(e) {
+  return e === "" ? 0 : Number.parseInt(e, 10);
+}
+function Qs(e) {
+  if (e === void 0)
+    return "";
+  const t = Number.parseFloat(e);
+  return Number.isNaN(t) ? e : t;
+}
+function _n(e) {
+  const t = e.indexOf(".");
+  if (t < 0)
+    return 0;
+  let n, r;
+  return t >= 3 ? (n = e.substring(0, t - 2), r = e.substring(t - 2)) : (n = "0", r = e), Number.parseFloat(n) + Number.parseFloat(r) / 60;
+}
+function $s(e, t) {
+  const n = t === "N" ? 1 : -1;
+  return _n(e) * n;
+}
+function ei(e, t) {
+  const n = t === "E" ? 1 : -1;
+  return _n(e) * n;
+}
+function os(e, t) {
+  if (e.length === 4)
+    return Number(e);
+  if (e.length === 2)
+    if (t) {
+      let n = Number(e);
+      return n < 73 ? n = 2e3 + n : n = 1900 + n, n;
+    } else
+      return +`20${e}`;
+  else
+    throw new Error(`Unexpected year string: ${e}`);
+}
+function ti(e, t, n = !1) {
+  if (e === "")
+    return /* @__PURE__ */ new Date(0);
+  const r = /* @__PURE__ */ new Date();
+  if (t) {
+    const a = t.slice(4), c = Number.parseInt(t.slice(2, 4), 10) - 1, u = t.slice(0, 2);
+    r.setUTCFullYear(os(a, n), Number(c), Number(u));
+  }
+  r.setUTCHours(Number(e.slice(0, 2))), r.setUTCMinutes(Number(e.slice(2, 4))), r.setUTCSeconds(Number(e.slice(4, 6)));
+  const i = e.slice(7), o = i.length;
+  let s = 0;
+  return o !== 0 && (s = Number.parseFloat(i) * 10 ** (3 - o)), r.setUTCMilliseconds(Number(s)), r;
+}
+const as = "DBK", cs = "Depth Below Keel";
+function us(e, t) {
+  return {
+    ...dt.initStubFields(e, as, cs),
+    depthFeet: L(t[1]),
+    depthMeters: L(t[3]),
+    depthFathoms: L(t[5])
+  };
+}
+const ds = "DBS", fs = "Depth Below Surface";
+function ls(e, t) {
+  return {
+    ...dt.initStubFields(e, ds, fs),
+    depthFeet: L(t[1]),
+    depthMeters: L(t[3]),
+    depthFathoms: L(t[5])
+  };
+}
+const hs = "DPT", ps = "Depth of Water";
+function vs(e, t) {
+  return {
+    ...dt.initStubFields(e, hs, ps),
+    depthMeters: L(t[1]),
+    offsetMeters: L(t[2]),
+    maximumRangeScale: L(t[3])
+  };
+}
+function bn(e, t) {
+  switch (e.talkerId) {
+    case "DBS":
+      return ls(e, t);
+    case "DBK":
+      return us(e, t);
+    case "DPT":
+      return vs(e, t);
+    default:
+      return null;
+  }
+}
+class ms extends Le.DefaultPacketFactory {
+  assembleCustomPacket(t, n) {
+    return bn(t, n);
+  }
+}
+const gs = new ms();
+function ni(e) {
+  return Le.parseGenericPacket(e, gs);
+}
+class ys extends Le.DefaultPacketFactory {
+  constructor() {
+    super(!0);
+  }
+  assembleCustomPacket(t, n) {
+    const r = bn(t, n);
+    return r || rs.decodeSentence(t, n);
+  }
+}
+const Ss = new ys();
+function _s(e) {
+  return Le.parseGenericPacket(e, Ss);
+}
+function Jt(e, t) {
+  return !t || t.length === 0 ? !0 : e !== void 0 && t.includes(e);
+}
+class bs {
+  /** Buffer for incomplete lines that span multiple chunks. */
+  container;
+  constructor() {
+    this.container = "";
+  }
+  /**
+   * Transforms incoming text chunks by splitting on \r\n and emitting complete lines.
+   * Incomplete lines are buffered until the next chunk arrives.
+   *
+   * @param chunk - The text chunk to process.
+   * @param controller - The transform stream controller to enqueue complete lines.
+   */
+  transform(t, n) {
+    this.container += t;
+    const r = this.container.split(`\r
+`), i = r.pop();
+    this.container = i ?? "", r.forEach((o) => {
+      o.length > 0 && n.enqueue(o);
+    });
+  }
+  /**
+   * Flushes any remaining buffered data when the stream closes.
+   * Incomplete NMEA sentences are discarded as they cannot be reliably parsed.
+   *
+   * @param controller - The transform stream controller (required by interface but unused).
+   */
+  flush(t) {
+    this.container = "";
+  }
+}
+const Ts = vn(async ({ input: e }) => {
+  if (!navigator.serial)
+    throw new Error("Web Serial API is not supported in this browser.");
+  console.log("Requesting serial port...");
+  const t = await navigator.serial.requestPort();
+  if (console.log(`Opening port at ${e.baudRate} baud...`), t.readable || t.writable) {
+    console.log("Port is already open, closing first...");
+    try {
+      await t.close();
+    } catch (n) {
+      console.warn("Error closing already-open port:", n);
+    }
+  }
+  return await t.open({ baudRate: e.baudRate }), console.log("Port open."), t;
+}), Is = vn(async ({ input: e }) => {
+  if (e.port)
+    try {
+      (e.port.readable || e.port.writable) && (await e.port.close(), console.log("Port closed successfully."));
+    } catch (t) {
+      console.warn("Error closing port:", t);
+    }
+}), ws = Sr(
+  ({ input: e, sendBack: t, receive: n }) => {
+    const { port: r } = e;
+    if (!r || !r.readable) {
+      t({ type: "SERIAL.ERROR", error: "Invalid port context." });
+      return;
+    }
+    const i = new bs(), s = r.readable.pipeThrough(new TextDecoderStream()).pipeThrough(
+      new TransformStream({
+        transform: i.transform.bind(i),
+        flush: i.flush.bind(i)
+      })
+    ).getReader();
+    let a = !0;
+    async function c() {
+      try {
+        for (; a; ) {
+          const { value: u, done: f } = await s.read();
+          if (f)
+            break;
+          if (u && u.length > 0)
+            try {
+              const l = _s(u);
+              if (l.sentenceId === "?")
+                continue;
+              t({ type: "SERIAL.DATA", data: l });
+            } catch (l) {
+              const d = l instanceof Error ? l.message : String(l);
+              console.warn("Failed to parse NMEA sentence:", u, d), t({
+                type: "SERIAL.ERROR",
+                error: `Parser Error: ${d}`
+              });
+            }
+        }
+      } catch (u) {
+        if (console.error("Read loop error:", u), a) {
+          const f = u instanceof Error ? u.message : String(u);
+          t({ type: "FATAL_ERROR", error: f });
+        }
+      } finally {
+        console.log("Read loop finished."), t({ type: "SERIAL.DISCONNECTED" });
+      }
+    }
+    return c(), n((u) => {
+      u.type === "STOP" && (console.log("Received STOP, cancelling reader..."), a = !1, s.cancel().catch(() => {
+      }));
+    }), () => {
+      console.log("Cleaning up stream reader actor..."), a = !1, s && s.cancel().catch(() => {
+      });
+    };
+  }
+);
+function ks(e) {
+  const { adapter: t, allowedSentenceIds: n, initialData: r, initialPackets: i } = e;
+  return gn({
+    actors: {
+      connectToSerial: Ts,
+      readNmeaStream: ws,
+      closePort: Is
+    },
+    actions: {
+      /**
+       * Sets the serial port in context and clears any error.
+       */
+      setPort: O((o, s) => ({
+        port: s.port,
+        error: null
+      })),
+      /**
+       * Sets an error message in context from a connection error.
+       */
+      setError: O((o, s) => {
+        const a = s.error;
+        let c;
+        return typeof a == "string" ? c = a : a instanceof Error ? c = a.message || "Failed to connect." : c = String(a) || "Failed to connect.", { error: c };
+      }),
+      /**
+       * Logs parsed NMEA packet data to the console.
+       * Only logs packets with allowed sentence IDs if logging is enabled.
+       */
+      logParsedData: ({ context: o }, s) => {
+        if (!o.enableLogging)
+          return;
+        const c = s.packet.sentenceId;
+        Jt(c, n) && console.log(`${c} Packet:`, s.packet);
+      },
+      /**
+       * Stores a parsed NMEA packet in context and recomputes data via the adapter.
+       * Only stores packets with allowed sentence IDs (if filtering is configured).
+       */
+      storePacket: O(({ context: o }, s) => {
+        const c = s.packet.sentenceId;
+        if (c && Jt(c, n)) {
+          const u = {
+            ...o.packets,
+            [c]: s.packet
+          };
+          return {
+            packets: u,
+            data: t(u),
+            error: null
+          };
+        }
+        return {
+          packets: o.packets,
+          data: t(o.packets),
+          error: null
+        };
+      }),
+      /**
+       * Sets a serial error message in context.
+       */
+      clearError: O((o, s) => ({
+        error: s.error
+      })),
+      /**
+       * Sets a fatal error message in context.
+       */
+      setFatalError: O((o, s) => ({
+        error: s.error
+      })),
+      /**
+       * Resets the machine context to disconnected state.
+       */
+      disconnect: O({
+        port: null,
+        error: null,
+        packets: i,
+        data: r
+      }),
+      /**
+       * Sets the logging enabled state.
+       */
+      setLogging: O((o, s) => ({
+        enableLogging: s.enabled
+      })),
+      /**
+       * Sets the baud rate for serial communication.
+       */
+      setBaudRate: O((o, s) => ({
+        baudRate: s.baudRate
+      }))
+    }
+  }).createMachine({
+    id: "nmea",
+    initial: "disconnected",
+    context: {
+      port: null,
+      error: null,
+      packets: i,
+      data: r,
+      enableLogging: !1,
+      baudRate: 4800
+    },
+    on: {
+      SET_LOGGING: {
+        actions: {
+          type: "setLogging",
+          params: ({ event: o }) => ({ enabled: o.enabled })
+        }
+      }
+    },
+    states: {
+      disconnected: {
+        on: {
+          CONNECT: "connecting",
+          SET_BAUD_RATE: {
+            actions: {
+              type: "setBaudRate",
+              params: ({ event: o }) => ({ baudRate: o.baudRate })
+            }
+          }
+        }
+      },
+      connecting: {
+        invoke: {
+          id: "connectToSerial",
+          src: "connectToSerial",
+          input: ({ context: o }) => ({ baudRate: o.baudRate }),
+          onDone: {
+            target: "connected",
+            actions: {
+              type: "setPort",
+              params: ({ event: o }) => ({ port: o.output })
+            }
+          },
+          onError: {
+            target: "error",
+            actions: {
+              type: "setError",
+              params: ({ event: o }) => ({ error: o.error })
+            }
+          }
+        }
+      },
+      connected: {
+        on: {
+          "SERIAL.DATA": {
+            actions: [
+              {
+                type: "logParsedData",
+                params: ({ event: o }) => ({ packet: o.data })
+              },
+              {
+                type: "storePacket",
+                params: ({ event: o }) => ({ packet: o.data })
+              }
+            ]
+          },
+          "SERIAL.ERROR": {
+            actions: {
+              type: "clearError",
+              params: ({ event: o }) => ({ error: o.error })
+            }
+          },
+          FATAL_ERROR: {
+            target: "error",
+            actions: {
+              type: "setFatalError",
+              params: ({ event: o }) => ({ error: o.error })
+            }
+          },
+          "SERIAL.DISCONNECTED": {
+            target: "disconnecting"
+          },
+          DISCONNECT: {
+            actions: Ge("streamReader", { type: "STOP" })
+          }
+        },
+        invoke: {
+          id: "streamReader",
+          src: "readNmeaStream",
+          input: ({ context: o }) => ({ port: o.port })
+        }
+      },
+      disconnecting: {
+        invoke: {
+          id: "closePort",
+          src: "closePort",
+          input: ({ context: o }) => ({ port: o.port }),
+          onDone: {
+            target: "disconnected",
+            actions: "disconnect"
+          },
+          onError: {
+            target: "disconnected",
+            actions: "disconnect"
+          }
+        }
+      },
+      error: {
+        on: {
+          CONNECT: "connecting"
+        }
+      }
+    }
+  });
+}
+function Ps(e, t, n) {
+  return e && e.fixType !== "none" ? {
+    latitude: e.latitude,
+    longitude: e.longitude,
+    source: "GGA",
+    fixType: e.fixType,
+    altitudeMeters: e.altitudeMeters,
+    satellitesInView: e.satellitesInView,
+    horizontalDilution: e.horizontalDilution
+  } : t && t.status === "valid" ? {
+    latitude: t.latitude,
+    longitude: t.longitude,
+    source: "RMC",
+    status: t.status
+  } : n && n.status === "valid" ? {
+    latitude: n.latitude,
+    longitude: n.longitude,
+    source: "GLL",
+    status: "valid"
+  } : null;
+}
+function Ds(e, t, n, r) {
+  if (e) {
+    const i = new Date(e.datetime), o = e.localZoneHours * 60 + e.localZoneMinutes;
+    return i.setMinutes(i.getMinutes() + o), {
+      utc: e.datetime,
+      local: i,
+      source: "ZDA"
+    };
+  }
+  return t && t.fixType !== "none" ? {
+    utc: t.time,
+    local: null,
+    source: "GGA"
+  } : n && n.status === "valid" ? {
+    utc: n.datetime,
+    local: null,
+    source: "RMC"
+  } : r && r.status === "valid" ? {
+    utc: r.time,
+    local: null,
+    source: "GLL"
+  } : null;
+}
+function Ms(e, t) {
+  return e ? { knots: e.speedKnots, source: "VTG" } : t && t.status === "valid" ? { knots: t.speedKnots, source: "RMC" } : null;
+}
+function As(e) {
+  return e.variationDirection === "W" ? -e.variation : (e.variationDirection === "E", e.variation);
+}
+function Es(e, t, n, r, i, o) {
+  if (e && e.heading !== void 0)
+    return { degreesTrue: e.heading, source: "HDT", isDerived: !1 };
+  if (t && t.heading !== void 0) {
+    const a = As(t);
+    return {
+      degreesTrue: t.heading + a,
+      source: "HDG",
+      isDerived: !1
+    };
+  }
+  if (n && n.heading !== void 0 && o !== void 0)
+    return {
+      degreesTrue: n.heading + o,
+      source: "HDM",
+      isDerived: !1
+    };
+  const s = r?.trackTrue ?? i?.trackTrue;
+  return s !== void 0 ? { degreesTrue: s, source: "COG", isDerived: !0 } : null;
+}
+function Fs(e, t, n, r) {
+  return e && e.depthMeters !== void 0 ? { meters: e.depthMeters, source: "DPT" } : t ? { meters: t.depthMeters, source: "DBT" } : n && n.depthMeters !== void 0 ? { meters: n.depthMeters, source: "DBS" } : r && r.depthMeters !== void 0 ? { meters: r.depthMeters, source: "DBK" } : null;
+}
+function Os(e, t) {
+  const n = Ds(e.ZDA, e.GGA, e.RMC, e.GLL), r = Ps(e.GGA, e.RMC, e.GLL), i = Ms(e.VTG, e.RMC), o = Es(
+    e.HDT,
+    e.HDG,
+    e.HDM,
+    e.RMC,
+    e.VTG,
+    t
+  ), s = Fs(
+    e.DPT,
+    e.DBT,
+    e.DBS,
+    e.DBK
+  );
+  return { time: n, position: r, speed: i, heading: o, depth: s };
+}
+const Ns = [
+  "GGA",
+  "RMC",
+  "GLL",
+  "VTG",
+  "HDT",
+  "HDG",
+  "HDM",
+  "DPT",
+  "DBT",
+  "DBS",
+  "DBK",
+  "ZDA"
+];
+function Cs(e) {
+  return (t) => Os(t, e);
+}
+const Rs = {
+  time: null,
+  position: null,
+  speed: null,
+  heading: null,
+  depth: null
+}, js = {};
+function Gs(e) {
+  return {
+    adapter: Cs(e?.externalVariation),
+    allowedSentenceIds: e?.allowedSentenceIds ?? Ns,
+    initialData: Rs,
+    initialPackets: js
+  };
+}
+function ri(e) {
+  return ks(Gs(e));
+}
+export {
+  Ns as NAVIGATION_SENTENCE_IDS,
+  xs as appendChecksumFooter,
+  Os as computeNavigationData,
+  Sn as computeNmeaChecksum,
+  Cs as createNavigationAdapter,
+  Gs as createNavigationNmeaConfig,
+  ri as createNavigationNmeaMachine,
+  is as createNmeaChecksumFooter,
+  ks as createNmeaMachine,
+  Ws as encodeAltitude,
+  Bs as encodeAltitudeNoUnits,
+  Js as encodeDate,
+  zs as encodeDegrees,
+  qs as encodeFixed,
+  Vs as encodeGeoidalSeperation,
+  Ks as encodeGeoidalSeperationNoUnits,
+  Us as encodeLatitude,
+  Hs as encodeLongitude,
+  Ys as encodeTime,
+  Zs as encodeValue,
+  Rs as initialNavigationData,
+  js as initialNavigationPackets,
+  G as padLeft,
+  _n as parseDmCoordinate,
+  L as parseFloatSafe,
+  Xs as parseIntSafe,
+  $s as parseLatitude,
+  ei as parseLongitude,
+  ni as parseNmeaSentence,
+  Qs as parseNumberOrString,
+  ti as parseTime,
+  _s as parseUnsafeNmeaSentence,
+  ss as toHexString,
+  Ls as validNmeaChecksum
+};