xstate 5.13.2 → 5.15.0

package/dist/{raise-ff8990f7.cjs.js → raise-a6298350.cjs.js}

@@ -59,8 +59,8 @@ const XSTATE_ERROR = 'xstate.error';
 const XSTATE_STOP = 'xstate.stop';
 
 /**
- * Returns an event that represents an implicit event that
- * is sent after the specified `delay`.
+ * Returns an event that represents an implicit event that is sent after the
+ * specified `delay`.
  *
  * @param delayRef The delay in milliseconds
  * @param id The state node ID where this event is handled
@@ -72,8 +72,8 @@ function createAfterEvent(delayRef, id) {
 }
 
 /**
- * Returns an event that represents that a final state node
- * has been reached in the parent state node.
+ * Returns an event that represents that a final state node has been reached in
+ * the parent state node.
  *
  * @param id The final state node's parent state node `id`
  * @param output The data to pass into the event
@@ -88,8 +88,8 @@ function createDoneStateEvent(id, output) {
 /**
  * Returns an event that represents that an invoked service has terminated.
  *
- * An invoked service is terminated when it has reached a top-level final state node,
- * but not when it is canceled.
+ * An invoked service is terminated when it has reached a top-level final state
+ * node, but not when it is canceled.
  *
  * @param invokeId The invoked service ID
  * @param output The data to pass into the event
@@ -97,13 +97,15 @@ function createDoneStateEvent(id, output) {
 function createDoneActorEvent(invokeId, output) {
   return {
     type: `xstate.done.actor.${invokeId}`,
-    output
+    output,
+    actorId: invokeId
   };
 }
 function createErrorActorEvent(id, error) {
   return {
     type: `xstate.error.actor.${id}`,
-    error
+    error,
+    actorId: id
   };
 }
 function createInitEvent(input) {
@@ -114,11 +116,12 @@ function createInitEvent(input) {
 }
 
 /**
- * This function makes sure that unhandled errors are thrown in a separate macrotask.
- * It allows those errors to be detected by global error handlers and reported to bug tracking services
- * without interrupting our own stack of execution.
+ * This function makes sure that unhandled errors are thrown in a separate
+ * macrotask. It allows those errors to be detected by global error handlers and
+ * reported to bug tracking services without interrupting our own stack of
+ * execution.
  *
- * @param err error to be thrown
+ * @param err Error to be thrown
  */
 function reportUnhandledError(err) {
   setTimeout(() => {
@@ -128,134 +131,6 @@ function reportUnhandledError(err) {
 
 const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
 
-function createScheduledEventId(actorRef, id) {
-  return `${actorRef.sessionId}.${id}`;
-}
-let idCounter = 0;
-function createSystem(rootActor, options) {
-  const children = new Map();
-  const keyedActors = new Map();
-  const reverseKeyedActors = new WeakMap();
-  const inspectionObservers = new Set();
-  const timerMap = {};
-  const {
-    clock,
-    logger
-  } = options;
-  const scheduler = {
-    schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
-      const scheduledEvent = {
-        source,
-        target,
-        event,
-        delay,
-        id,
-        startedAt: Date.now()
-      };
-      const scheduledEventId = createScheduledEventId(source, id);
-      system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
-      const timeout = clock.setTimeout(() => {
-        delete timerMap[scheduledEventId];
-        delete system._snapshot._scheduledEvents[scheduledEventId];
-        system._relay(source, target, event);
-      }, delay);
-      timerMap[scheduledEventId] = timeout;
-    },
-    cancel: (source, id) => {
-      const scheduledEventId = createScheduledEventId(source, id);
-      const timeout = timerMap[scheduledEventId];
-      delete timerMap[scheduledEventId];
-      delete system._snapshot._scheduledEvents[scheduledEventId];
-      clock.clearTimeout(timeout);
-    },
-    cancelAll: actorRef => {
-      for (const scheduledEventId in system._snapshot._scheduledEvents) {
-        const scheduledEvent = system._snapshot._scheduledEvents[scheduledEventId];
-        if (scheduledEvent.source === actorRef) {
-          scheduler.cancel(actorRef, scheduledEvent.id);
-        }
-      }
-    }
-  };
-  const sendInspectionEvent = event => {
-    if (!inspectionObservers.size) {
-      return;
-    }
-    const resolvedInspectionEvent = {
-      ...event,
-      rootId: rootActor.sessionId
-    };
-    inspectionObservers.forEach(observer => observer.next?.(resolvedInspectionEvent));
-  };
-  const system = {
-    _snapshot: {
-      _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
-    },
-    _bookId: () => `x:${idCounter++}`,
-    _register: (sessionId, actorRef) => {
-      children.set(sessionId, actorRef);
-      return sessionId;
-    },
-    _unregister: actorRef => {
-      children.delete(actorRef.sessionId);
-      const systemId = reverseKeyedActors.get(actorRef);
-      if (systemId !== undefined) {
-        keyedActors.delete(systemId);
-        reverseKeyedActors.delete(actorRef);
-      }
-    },
-    get: systemId => {
-      return keyedActors.get(systemId);
-    },
-    _set: (systemId, actorRef) => {
-      const existing = keyedActors.get(systemId);
-      if (existing && existing !== actorRef) {
-        throw new Error(`Actor with system ID '${systemId}' already exists.`);
-      }
-      keyedActors.set(systemId, actorRef);
-      reverseKeyedActors.set(actorRef, systemId);
-    },
-    inspect: observer => {
-      inspectionObservers.add(observer);
-    },
-    _sendInspectionEvent: sendInspectionEvent,
-    _relay: (source, target, event) => {
-      system._sendInspectionEvent({
-        type: '@xstate.event',
-        sourceRef: source,
-        actorRef: target,
-        event
-      });
-      target._send(event);
-    },
-    scheduler,
-    getSnapshot: () => {
-      return {
-        _scheduledEvents: {
-          ...system._snapshot._scheduledEvents
-        }
-      };
-    },
-    start: () => {
-      const scheduledEvents = system._snapshot._scheduledEvents;
-      system._snapshot._scheduledEvents = {};
-      for (const scheduledId in scheduledEvents) {
-        const {
-          source,
-          target,
-          event,
-          delay,
-          id
-        } = scheduledEvents[scheduledId];
-        scheduler.schedule(source, target, event, delay, id);
-      }
-    },
-    _clock: clock,
-    _logger: logger
-  };
-  return system;
-}
-
 function matchesState(parentStateId, childStateId) {
   const parentStateValue = toStateValue(parentStateId);
   const childStateValue = toStateValue(childStateId);
@@ -410,6 +285,140 @@ function getAllOwnEventDescriptors(snapshot) {
   return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])];
 }
 
+function createScheduledEventId(actorRef, id) {
+  return `${actorRef.sessionId}.${id}`;
+}
+let idCounter = 0;
+function createSystem(rootActor, options) {
+  const children = new Map();
+  const keyedActors = new Map();
+  const reverseKeyedActors = new WeakMap();
+  const inspectionObservers = new Set();
+  const timerMap = {};
+  const {
+    clock,
+    logger
+  } = options;
+  const scheduler = {
+    schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
+      const scheduledEvent = {
+        source,
+        target,
+        event,
+        delay,
+        id,
+        startedAt: Date.now()
+      };
+      const scheduledEventId = createScheduledEventId(source, id);
+      system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
+      const timeout = clock.setTimeout(() => {
+        delete timerMap[scheduledEventId];
+        delete system._snapshot._scheduledEvents[scheduledEventId];
+        system._relay(source, target, event);
+      }, delay);
+      timerMap[scheduledEventId] = timeout;
+    },
+    cancel: (source, id) => {
+      const scheduledEventId = createScheduledEventId(source, id);
+      const timeout = timerMap[scheduledEventId];
+      delete timerMap[scheduledEventId];
+      delete system._snapshot._scheduledEvents[scheduledEventId];
+      clock.clearTimeout(timeout);
+    },
+    cancelAll: actorRef => {
+      for (const scheduledEventId in system._snapshot._scheduledEvents) {
+        const scheduledEvent = system._snapshot._scheduledEvents[scheduledEventId];
+        if (scheduledEvent.source === actorRef) {
+          scheduler.cancel(actorRef, scheduledEvent.id);
+        }
+      }
+    }
+  };
+  const sendInspectionEvent = event => {
+    if (!inspectionObservers.size) {
+      return;
+    }
+    const resolvedInspectionEvent = {
+      ...event,
+      rootId: rootActor.sessionId
+    };
+    inspectionObservers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+  };
+  const system = {
+    _snapshot: {
+      _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
+    },
+    _bookId: () => `x:${idCounter++}`,
+    _register: (sessionId, actorRef) => {
+      children.set(sessionId, actorRef);
+      return sessionId;
+    },
+    _unregister: actorRef => {
+      children.delete(actorRef.sessionId);
+      const systemId = reverseKeyedActors.get(actorRef);
+      if (systemId !== undefined) {
+        keyedActors.delete(systemId);
+        reverseKeyedActors.delete(actorRef);
+      }
+    },
+    get: systemId => {
+      return keyedActors.get(systemId);
+    },
+    _set: (systemId, actorRef) => {
+      const existing = keyedActors.get(systemId);
+      if (existing && existing !== actorRef) {
+        throw new Error(`Actor with system ID '${systemId}' already exists.`);
+      }
+      keyedActors.set(systemId, actorRef);
+      reverseKeyedActors.set(actorRef, systemId);
+    },
+    inspect: observerOrFn => {
+      const observer = toObserver(observerOrFn);
+      inspectionObservers.add(observer);
+      return {
+        unsubscribe() {
+          inspectionObservers.delete(observer);
+        }
+      };
+    },
+    _sendInspectionEvent: sendInspectionEvent,
+    _relay: (source, target, event) => {
+      system._sendInspectionEvent({
+        type: '@xstate.event',
+        sourceRef: source,
+        actorRef: target,
+        event
+      });
+      target._send(event);
+    },
+    scheduler,
+    getSnapshot: () => {
+      return {
+        _scheduledEvents: {
+          ...system._snapshot._scheduledEvents
+        }
+      };
+    },
+    start: () => {
+      const scheduledEvents = system._snapshot._scheduledEvents;
+      system._snapshot._scheduledEvents = {};
+      for (const scheduledId in scheduledEvents) {
+        const {
+          source,
+          target,
+          event,
+          delay,
+          id
+        } = scheduledEvents[scheduledId];
+        scheduler.schedule(source, target, event, delay, id);
+      }
+    },
+    _clock: clock,
+    _logger: logger
+  };
+  return system;
+}
+
 const $$ACTOR_TYPE = 1;
 // those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync
 let ProcessingStatus = /*#__PURE__*/function (ProcessingStatus) {
@@ -432,29 +441,29 @@ const defaultOptions = {
 };
 
 /**
- * An Actor is a running process that can receive events, send events and change its behavior based on the events it receives, which can cause effects outside of the actor. When you run a state machine, it becomes an actor.
+ * An Actor is a running process that can receive events, send events and change
+ * its behavior based on the events it receives, which can cause effects outside
+ * of the actor. When you run a state machine, it becomes an actor.
  */
 class Actor {
   /**
-   * Creates a new actor instance for the given logic with the provided options, if any.
+   * 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(logic, options) {
     this.logic = logic;
-    /**
-     * The current internal state of the actor.
-     */
+    /** The current internal state of the actor. */
     this._snapshot = void 0;
     /**
-     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     * The clock that is responsible for setting and clearing timeouts, such as
+     * delayed events and transitions.
      */
     this.clock = void 0;
     this.options = void 0;
-    /**
-     * The unique identifier for this actor relative to its parent.
-     */
+    /** The unique identifier for this actor relative to its parent. */
     this.id = void 0;
     this.mailbox = new Mailbox(this._process.bind(this));
     this.observers = new Set();
@@ -470,13 +479,9 @@ class Actor {
     // TODO: add typings for system
     this._actorScope = void 0;
     this._systemId = void 0;
-    /**
-     * The globally unique process ID for this invocation.
-     */
+    /** The globally unique process ID for this invocation. */
     this.sessionId = void 0;
-    /**
-     * The system to which this actor belongs.
-     */
+    /** The system to which this actor belongs. */
     this.system = void 0;
     this._doneEvent = void 0;
     this.src = void 0;
@@ -640,11 +645,15 @@ class Actor {
    * 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:
+   * 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
+   * - An observer object whose `.next(snapshot)` method receives the latest
+   *   snapshot
    *
    * @example
+   *
    * ```ts
    * // Observer as a plain function
    * const subscription = actor.subscribe((snapshot) => {
@@ -653,6 +662,7 @@ class Actor {
    * ```
    *
    * @example
+   *
    * ```ts
    * // Observer as an object
    * const subscription = actor.subscribe({
@@ -664,13 +674,16 @@ class Actor {
    *   },
    *   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:
+   * 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) => {
    *   // ...
@@ -680,9 +693,12 @@ class Actor {
    * subscription.unsubscribe();
    * ```
    *
-   * When the actor is stopped, all of its observers will automatically be unsubscribed.
+   * 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
+   * @param observer - Either a plain function that receives the latest
+   *   snapshot, or an observer object whose `.next(snapshot)` method receives
+   *   the latest snapshot
    */
 
   subscribe(nextListenerOrObserver, errorListener, completeListener) {
@@ -735,9 +751,7 @@ class Actor {
     };
   }
 
-  /**
-   * Starts the Actor from the initial state
-   */
+  /** Starts the Actor from the initial state */
   start() {
     if (this._processingStatus === ProcessingStatus.Running) {
       // Do not restart the service if it is already started
@@ -853,9 +867,7 @@ class Actor {
     return this;
   }
 
-  /**
-   * Stops the Actor and unsubscribe all listeners.
-   */
+  /** Stops the Actor and unsubscribe all listeners. */
   stop() {
     if (this._parent) {
       throw new Error('A non-root actor cannot be stopped directly.');
@@ -927,9 +939,7 @@ class Actor {
     return this;
   }
 
-  /**
-   * @internal
-   */
+  /** @internal */
   _send(event) {
     if (this._processingStatus === ProcessingStatus.Stopped) {
       return;
@@ -967,10 +977,11 @@ class Actor {
    * @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.
+   * 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
    */
 
@@ -987,11 +998,11 @@ class Actor {
    * @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.
+   * 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).
    */
@@ -1000,13 +1011,16 @@ class Actor {
   }
 }
 /**
- * Creates a new actor instance for the given actor logic with the provided options, if any.
+ * Creates a new actor instance for the given actor logic with the provided
+ * options, if any.
  *
  * @remarks
- * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
- * Any actors spawned from this root actor and its descendants are part of that actor system.
- *
+ * When you create an actor from actor logic via `createActor(logic)`, you
+ * implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that
+ * actor system.
  * @example
+ *
  * ```ts
  * import { createActor } from 'xstate';
  * import { someActorLogic } from './someActorLogic.ts';
@@ -1028,7 +1042,10 @@ class Actor {
  * actor.stop();
  * ```
  *
- * @param logic - The actor logic to create an actor from. For a state machine actor logic creator, see {@link createMachine}. Other actor logic creators include {@link fromCallback}, {@link fromEventObservable}, {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
+ * @param logic - The actor logic to create an actor from. For a state machine
+ *   actor logic creator, see {@link createMachine}. Other actor logic creators
+ *   include {@link fromCallback}, {@link fromEventObservable},
+ *   {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
  * @param options - Actor options
  */
 function createActor(logic, ...[options]) {
@@ -1036,15 +1053,14 @@ function createActor(logic, ...[options]) {
 }
 
 /**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ * Creates a new Interpreter instance for the given machine with the provided
+ * options, if any.
  *
  * @deprecated Use `createActor` instead
  */
 const interpret = createActor;
 
-/**
- * @deprecated Use `Actor` instead.
- */
+/** @deprecated Use `Actor` instead. */
 
 function resolveCancel(_, snapshot, actionArgs, actionParams, {
   sendId
@@ -1058,30 +1074,36 @@ function executeCancel(actorScope, resolvedSendId) {
   });
 }
 /**
- * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The canceled `sendTo(...)` action
- * will not send its event or execute, unless the `delay` has already elapsed before `cancel(...)` is called.
+ * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The
+ * canceled `sendTo(...)` action will not send its event or execute, unless the
+ * `delay` has already elapsed before `cancel(...)` is called.
  *
- * @param sendId The `id` of the `sendTo(...)` action to cancel.
- * 
  * @example
-  ```ts
-  import { createMachine, sendTo, cancel } from 'xstate';
-
-  const machine = createMachine({
-    // ...
-    on: {
-      sendEvent: {
-        actions: sendTo('some-actor', { type: 'someEvent' }, {
-          id: 'some-id',
-          delay: 1000
-        })
-      },
-      cancelEvent: {
-        actions: cancel('some-id')
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { createMachine, sendTo, cancel } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   // ...
+ *   on: {
+ *     sendEvent: {
+ *       actions: sendTo(
+ *         'some-actor',
+ *         { type: 'someEvent' },
+ *         {
+ *           id: 'some-id',
+ *           delay: 1000
+ *         }
+ *       )
+ *     },
+ *     cancelEvent: {
+ *       actions: cancel('some-id')
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @param sendId The `id` of the `sendTo(...)` action to cancel.
  */
 function cancel(sendId) {
   function cancel(args, params) {
@@ -1249,30 +1271,33 @@ function checkNot(snapshot, {
 }
 
 /**
- * Higher-order guard that evaluates to `true` if the `guard` passed to it evaluates to `false`.
+ * Higher-order guard that evaluates to `true` if the `guard` passed to it
+ * evaluates to `false`.
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, not } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => false
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: not('someNamedGuard'),
-        actions: () => {
-          // will be executed if guard in `not(...)`
-          // evaluates to `false`
-        }
-      }
-    }
-  });
-  ```
- * @returns A guard 
+ *
+ * ```ts
+ * import { setup, not } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => false
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: not('someNamedGuard'),
+ *       actions: () => {
+ *         // will be executed if guard in `not(...)`
+ *         // evaluates to `false`
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @returns A guard
  */
 function not(guard) {
   function not(args, params) {
@@ -1297,28 +1322,27 @@ function checkAnd(snapshot, {
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, and } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => true
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: and([
-          ({ context }) => context.value > 0,
-          'someNamedGuard'
-        ]),
-        actions: () => {
-          // will be executed if all guards in `and(...)`
-          // evaluate to true
-        }
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { setup, and } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => true
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: and([({ context }) => context.value > 0, 'someNamedGuard']),
+ *       actions: () => {
+ *         // will be executed if all guards in `and(...)`
+ *         // evaluate to true
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * @returns A guard action object
  */
 function and(guards) {
@@ -1339,33 +1363,32 @@ function checkOr(snapshot, {
 }
 
 /**
- * Higher-order guard that evaluates to `true` if any of the `guards` passed to it
- * evaluate to `true`.
+ * Higher-order guard that evaluates to `true` if any of the `guards` passed to
+ * it evaluate to `true`.
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, or } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => true
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: or([
-          ({ context }) => context.value > 0,
-          'someNamedGuard'
-        ]),
-        actions: () => {
-          // will be executed if any of the guards in `or(...)`
-          // evaluate to true
-        }
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { setup, or } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => true
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: or([({ context }) => context.value > 0, 'someNamedGuard']),
+ *       actions: () => {
+ *         // will be executed if any of the guards in `or(...)`
+ *         // evaluate to true
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * @returns A guard action object
  */
 function or(guards) {
@@ -1542,9 +1565,7 @@ function getCandidates(stateNode, receivedEventType) {
   return candidates;
 }
 
-/**
- * All delayed transitions from the config.
- */
+/** All delayed transitions from the config. */
 function getDelayedTransitions(stateNode) {
   const afterConfig = stateNode.config.after;
   if (!afterConfig) {
@@ -1731,9 +1752,7 @@ function getInitialStateNodes(stateNode) {
   iter(stateNode);
   return set;
 }
-/**
- * Returns the child state node from its relative `stateKey`, or throws.
- */
+/** Returns the child state node from its relative `stateKey`, or throws. */
 function getStateNode(stateNode, stateKey) {
   if (isStateId(stateKey)) {
     return stateNode.machine.getStateNodeById(stateKey);
@@ -1974,9 +1993,7 @@ function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
   return true;
 }
 
-/**
- * https://www.w3.org/TR/scxml/#microstepProcedure
- */
+/** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentSnapshot;
@@ -2386,7 +2403,8 @@ function selectEventlessTransitions(nextState, event) {
 }
 
 /**
- * Resolves a partial state value with its full representation in the state node's machine.
+ * Resolves a partial state value with its full representation in the state
+ * node's machine.
  *
  * @param stateValue The partial state value to resolve.
  */