@xmachines/play-xstate 2.0.0 → 2.1.0

package/dist/player-actor.d.ts

@@ -3,28 +3,31 @@ import { AbstractActor, type Routable, type Viewable, type PlaySpec } from "@xma
 import { Signal } from "@xmachines/play-signals";
 import type { PlayerOptions } from "./types.js";
 /**
- * Concrete XState actor implementing Play Architecture signal protocol
+ * The concrete XState actor. It implements the signal protocol of the Play Architecture
  *
- * Extends {@link @xmachines/play-actor!AbstractActor} — and so XState's own `Actor` —
- * to provide XState v5 integration while maintaining ecosystem compatibility (XState
- * inspection, devtools). The machine is handed to the base constructor, so a
- * `PlayerActor` **is** the XState actor rather than a wrapper around one: everything
- * XState's `Actor` exposes operates on this instance's own state, and the class adds
- * TC39 Signal-based reactive state for Infrastructure observation on top.
+ * The class extends {@link @xmachines/play-actor!AbstractActor}, and therefore the
+ * `Actor` class of XState. It gives you the XState v5 integration, and it keeps the
+ * compatibility with the ecosystem, such as the XState inspection and the devtools.
+ * The constructor of the base class receives the machine. Therefore a `PlayerActor`
+ * **is** the XState actor, and it is no wrapper around one: every member of the
+ * XState `Actor` class works on the state of this instance, and this class adds the
+ * reactive state on the TC39 Signals for the observation by the infrastructure.
  *
- * **Capabilities:** Implements both {@link @xmachines/play-actor!Routable} and
- * {@link @xmachines/play-actor!Viewable} interfaces, providing routing and view
- * rendering support.
+ * **Capabilities:** the class implements both the
+ * {@link @xmachines/play-actor!Routable} interface and the
+ * {@link @xmachines/play-actor!Viewable} interface. It therefore supports the
+ * routing and the view rendering.
  *
- * **Architectural Context:** Implements **Actor Authority (INV-01)** by ensuring the
- * XState machine's guards control all navigation decisions. Infrastructure observes
- * the actor's signals (`state`, `currentRoute`, `currentView`) but cannot directly
- * manipulate state—all mutations flow through the state machine's event handlers.
+ * **Architectural context:** the class implements **Actor Authority (INV-01)**,
+ * because the guards of the XState machine control every decision of the
+ * navigation. The infrastructure observes the signals of the actor (`state`,
+ * `currentRoute`, and `currentView`), but it changes no state directly: every
+ * change goes through the event handlers of the state machine.
  *
- * @typeParam TMachine - XState v5 state machine type
+ * @typeParam TMachine - The type of the XState v5 state machine
  *
  * @example
- * Basic actor creation and lifecycle
+ * The creation of an actor, and its lifecycle
  * ```typescript
  * import { setup } from "xstate";
  * import { definePlayer } from "@xmachines/play-xstate";
@@ -35,7 +38,7 @@ import type { PlayerOptions } from "./types.js";
  *     idle: {
  *       meta: {
  *         route: '/',
- *         // A view spec needs `root` and `elements` — other shapes derive null.
+ *         // A view spec needs `root` and `elements`. Every other shape derives null.
  *         view: {
  *           root: 'home',
  *           elements: { home: { type: 'HomePage', props: {}, children: [] } },
@@ -49,13 +52,13 @@ import type { PlayerOptions } from "./types.js";
  * const actor = createPlayer();
  * actor.start();
  *
- * // Observe signals
+ * // Observe the signals
  * console.log(actor.currentRoute.get());          // '/'
  * console.log(actor.currentView.get()?.root);     // 'home'
  * ```
  *
  * @example
- * Signal lifecycle with watchers
+ * The signal lifecycle with a watcher
  * ```typescript
  * import { Signal } from "@xmachines/play-signals";
  *
@@ -68,82 +71,86 @@ import type { PlayerOptions } from "./types.js";
  *
  * watcher.watch(actor.state);
  * actor.send({ type: 'play.route', to: '#about' });
- * // Watcher notification scheduled via microtask by the watcher itself
+ * // The watcher schedules its own notification in a microtask
  * ```
  *
  * @see [Play RFC](../../docs/rfc/play.md)
- * @see {@link definePlayer} for factory creation
- * @see {@link @xmachines/play-actor!AbstractActor} for signal protocol
- * @see {@link @xmachines/play-actor!Routable} for routing capability
- * @see {@link @xmachines/play-actor!Viewable} for view rendering capability
+ * @see {@link definePlayer} for the creation through a factory
+ * @see {@link @xmachines/play-actor!AbstractActor} for the signal protocol
+ * @see {@link @xmachines/play-actor!Routable} for the routing capability
+ * @see {@link @xmachines/play-actor!Viewable} for the view rendering capability
  *
  * @remarks
- * **Routing:** This actor supports both XState's `route: {}` config pattern
- * and `play.route` events with parameters. The `deriveRoute()` function checks
- * `meta.route` (Stately pattern) for URL templates with parameter substitution support.
+ * **The routing:** this actor supports the `route: {}` config pattern of XState and
+ * also a `play.route` event with parameters. The `deriveRoute()` function reads
+ * `meta.route`, which is the Stately pattern, for a URL template, and it substitutes
+ * each parameter.
  *
- * **View Signal Pattern:** The `currentView` signal is a direct `Signal.State` (not
- * `Signal.Computed`) to ensure proper watcher propagation in PlayRenderer. Views are
- * cached and updated at state entry, not computed on every read.
+ * **The pattern of the view signal:** the `currentView` signal is a direct
+ * `Signal.State`, and not a `Signal.Computed`. The propagation to a watcher in
+ * PlayRenderer is therefore correct. The class derives each view at the entry of a
+ * state and keeps it, and it computes no view on a read.
  */
 export declare class PlayerActor<TMachine extends AnyStateMachine> extends AbstractActor<AnyActorLogic, EventFromLogic<TMachine>> implements Routable, Viewable {
     private playerOptions?;
     /**
-     * Whether this constructor has returned.
+     * Tells you if this constructor returned already.
      *
-     * XState hands the actor to a context factory as `self`, and to an
-     * `inspect` observer as `actorRef`, from inside its own constructor — where
-     * none of this class's fields exist yet and XState itself refuses to read
-     * the snapshot ("Snapshot can't be read while the actor initializes
-     * itself"). Anything reachable from that window has to check this first.
+     * XState gives the actor to a context factory as `self`, and to an `inspect`
+     * observer as `actorRef`, from inside its own constructor. No field of this class
+     * exists at that moment, and XState itself refuses to read the snapshot there:
+     * "Snapshot can't be read while the actor initializes itself". Therefore each thing
+     * that the code can reach from that window must test this field first.
      */
     private constructed?;
     /**
-     * The caller's live options bag, or an empty one during construction.
+     * The live options object of the caller, or an empty object during the construction.
      *
-     * XState hands this actor to a context factory as `self` and to an
-     * `inspect` observer as `actorRef` from inside its own constructor, before
-     * any field here is assigned. Reading hooks through this accessor keeps
-     * that window from throwing — a throw would be caught by XState's
-     * initialization and parked as an error snapshot — while preserving the
-     * read-at-delivery-time behaviour the bag's own docs promise.
+     * XState gives this actor to a context factory as `self`, and to an `inspect`
+     * observer as `actorRef`, from inside its own constructor, before the code assigns
+     * any field here. A read of a hook through this accessor therefore does not throw
+     * in that window. A throw goes to the initialization of XState, which parks it as
+     * an error snapshot. The accessor also keeps the behavior that the documentation of
+     * the object promises: a read at the moment of the delivery.
      *
-     * The window-sensitive fields below are `declare`d for the same reason.
-     * This target compiles class fields to `Object.defineProperty`, which runs
-     * after `super()` returns: a plain declaration — initializer or not — would
-     * reset anything the window had written back to `undefined`. `declare`
-     * emits nothing, so those writes survive.
+     * The fields below that this window touches have a `declare` modifier for the same
+     * reason. This target compiles a class field into `Object.defineProperty`, which
+     * runs after `super()` returns. A plain declaration, with an initializer or without
+     * one, therefore resets each value of the window to `undefined`. A `declare`
+     * modifier emits nothing, and those values survive.
      */
     private get hooks();
     /**
-     * Real lifecycle transitions, so onStart/onStop fire once each. XState's
-     * own status is internal, and a machine snapshot already reads "active"
-     * before start(), so neither can distinguish not-yet-started from running.
+     * The record of the real lifecycle transitions, so that onStart and onStop each
+     * fire one time. The status of XState is internal, and a machine snapshot reads
+     * "active" before start() already. Therefore neither of them can separate an actor
+     * that did not start yet from an actor that runs.
      */
     private lifecycle?;
     /**
-     * Userland subscriptions without an error listener. XState's dispatch
-     * rethrows an actor error globally on their behalf (once per delivery, a
-     * shared flag), so while one is active the internal error listener's own
-     * loud-default rethrow must stand down — or the same error is reported
-     * twice.
+     * The subscriptions of the user code without an error listener. The dispatch of
+     * XState throws an actor error again, globally, for them. It does this one time for
+     * each delivery, with a shared flag. Therefore the loud default of the internal
+     * error listener, which also throws again, must stand down while such a
+     * subscription is active. Without this rule, the code reports the same error two
+     * times.
      */
     private nextOnlySubscriptions?;
     /**
-     * The last snapshot the view pipeline processed. XState notifies observers
-     * on EVERY processed event — an ignored event redelivers the identical
-     * snapshot — and deriveCurrentView is pure in the snapshot, so an identical
-     * reference cannot change the outcome. Seeded with undefined (never a
-     * snapshot): the construction-time snapshot is reference-identical to the
-     * one start() replays, and seeding with it would suppress the initial view.
+     * The last snapshot of the view pipeline. XState notifies each observer on EVERY
+     * event that it processes, and an event that it ignores delivers the identical
+     * snapshot again. deriveCurrentView is pure in the snapshot. Therefore an identical
+     * reference can change no result. The first value is undefined, and never a
+     * snapshot: the snapshot of the construction has the same reference as the snapshot
+     * that start() replays, and that value therefore stops the first view.
      */
     private lastViewSnapshot;
     state: Signal.State<ReturnType<TMachine["transition"]>>;
     /**
-     * Returns whether the actor's current state can accept the given event.
+     * Tells you if the current state of the actor accepts the given event.
      *
-     * Typed to the machine's event union — passing an unknown event type is a
-     * compile error. Evaluated against the current snapshot signal.
+     * The type is the event union of the machine. An unknown event type is therefore a
+     * compile error. The method evaluates the event against the snapshot signal.
      *
      * @example
      * ```typescript
@@ -152,165 +159,174 @@ export declare class PlayerActor<TMachine extends AnyStateMachine> extends Abstr
      */
     can(event: EventFromLogic<TMachine>): boolean;
     /**
-     * A TC39 `Signal.Computed` that derives the current URL path from the active
-     * machine state's `meta.route` template and the actor's context.
+     * A TC39 `Signal.Computed`. It derives the current URL path from the `meta.route`
+     * template of the active machine state and from the context of the actor.
      *
-     * Returns `null` when the current state has no `meta.route`, or when the route
-     * template cannot be fully resolved — a required `:param` absent from context
-     * is caught internally (`MissingRouteParamError` never escapes `get()`): the
-     * condition is transient mid-transition and the signal recomputes on the next
+     * It returns `null` when the current state has no `meta.route` field, and also when
+     * it cannot resolve the complete route template. A necessary `:param` that the
+     * context does not hold is caught inside the signal, and a
+     * `MissingRouteParamError` therefore never leaves `get()`: that condition is
+     * temporary during a transition, and the signal computes the value again on the next
      * snapshot.
      *
      * @example
      * ```typescript
-     * // Returns "/profile/alice" when context.params.userId === "alice",
-     * // and null while the param is still missing.
+     * // It returns "/profile/alice" when context.params.userId === "alice",
+     * // and null while the param is still absent.
      * const route = actor.currentRoute.get();
      * ```
      */
     currentRoute: Signal.Computed<string | null>;
     /**
-     * The route derived from the machine's initial state — fixed at construction,
-     * never changes even when the actor is restored from a snapshot.
+     * The route of the initial state of the machine. The constructor fixes it, and it
+     * never changes, also when the code restores the actor from a snapshot.
      *
-     * Router bridges compare this against the browser URL to distinguish a deep-link
-     * (non-initial URL → router wins) from a restore (initial URL + actor at a
-     * different restored route → actor wins).
+     * A router bridge compares it with the browser URL, and it therefore separates a
+     * deep link (a URL that is not the initial one → the router wins) from a restore
+     * (the initial URL, and the actor at a different route from the restore → the actor
+     * wins).
      *
-     * Derived statically from the machine definition via `deriveInitialRoute`
-     * (XState's pure `initialTransition` helper): the initial state chain and its
-     * `meta.route` templates are fixed at machine definition time, while `:param`
-     * substitution uses the machine's real initial context for this actor's `input`.
-     * No extra actor is ever created, and a restored snapshot never influences the
-     * value — it is always the machine's **default** initial route.
+     * `deriveInitialRoute` derives the value statically from the machine definition,
+     * with the pure `initialTransition` helper of XState: the chain of the initial states
+     * and their `meta.route` templates are fixed at the moment of the machine
+     * definition, and the substitution of a `:param` uses the real initial context of
+     * the machine for the `input` of this actor. The code makes no second actor, and a
+     * snapshot of a restore changes the value never: it is always the **default**
+     * initial route of the machine.
      */
     readonly initialRoute: string | null;
     /**
-     * Reactive signal containing the current view spec derived from the active state's
-     * `meta.view` metadata.
+     * The reactive signal of the current view spec. The signal derives the spec from
+     * the `meta.view` metadata of the active state.
      *
-     * Emits a **fresh object reference** whenever the rendered view actually changes —
-     * a different state's view, or a param/context change that alters the resolved
-     * spec (including `reenter: true` re-entries with new params). Snapshots that do
-     * not change the rendered view (e.g. context-only assigns) keep the previous
-     * reference so downstream providers do not remount the UI on every event.
+     * It emits a **new object reference** on each real change of the view on the
+     * screen: the view of a different state, or a change of a param or of the context
+     * that changes the resolved spec. A re-entry with `reenter: true` and new params
+     * also changes the spec. A snapshot that changes no view on the screen, such as an
+     * assign of the context alone, keeps the previous reference. A provider below the
+     * signal therefore mounts the UI again not on every event.
      *
-     * The emitted `PlaySpec` carries the machine's context in its composed
-     * `state` under the read-only `/context` subtree, so specs read context —
-     * URL params included — through the ordinary state grammar
-     * (`{ $state: "/context/params/section" }`). See `@xmachines/play-actor`'s
-     * context-projection module for the full contract.
+     * The `PlaySpec` of the emission carries the context of the machine in its composed
+     * `state` field, under the read-only `/context` subtree. A spec therefore reads the
+     * context, and also each URL param, through the ordinary state grammar
+     * (`{ $state: "/context/params/section" }`). The context-projection module of
+     * `@xmachines/play-actor` holds the complete contract.
      *
-     * Returns `null` when the current state has no `meta.view` metadata.
+     * The signal returns `null` when the current state has no `meta.view` metadata.
      *
-     * Two states declaring separate but structurally identical `meta.view`
-     * literals emit distinct references on a transition between them (a
-     * provider remount); hoist the shared literal into one `typedSpec` constant
-     * to deduplicate by identity.
+     * Two states can declare two separate `meta.view` literals with an identical
+     * structure. A transition between those two states then emits two different
+     * references, and a provider mounts the UI again. Move the shared literal into one
+     * `typedSpec` constant, and the identity then removes the duplicate.
      *
      * @example
      * ```typescript
      * const view = actor.currentView.get();
      * if (view) {
-     *   console.log(view.root);     // e.g. "root"
-     *   console.log(view.elements); // @xmachines/json-render-core Spec elements
+     *   console.log(view.root);     // for example "root"
+     *   console.log(view.elements); // the Spec elements of @xmachines/json-render-core
      * }
      * ```
      */
     readonly currentView: Signal.State<PlaySpec | null>;
     constructor(machine: TMachine, options: PlayerOptions<TMachine>, input?: InputFrom<TMachine>, restoredSnapshot?: ActorOptions<TMachine>["snapshot"]);
     /**
-     * Start the actor.
+     * Starts the actor.
      *
-     * Fires `onStart` on each real start — every transition from not-running to
-     * running, including a start after a stop, which XState allows (its own
-     * `start()` bails only while the actor is already RUNNING). A repeated call
-     * while running does not re-fire it, so a defensive double mount does not
-     * re-run `onStart` side effects for one actual start.
+     * The method fires `onStart` on each real start, which is every transition from
+     * "not running" to "running". A start after a stop is such a transition, and XState
+     * permits it: its own `start()` stops only while the actor RUNS already. A second
+     * call while the actor runs fires no hook. Therefore a defensive double mount runs
+     * the side effects of `onStart` one time for one real start.
      */
     start(): this;
     /**
-     * Stop the actor and clean up.
+     * Stops the actor and cleans up.
      *
-     * Fires `onStop` only when the actor was actually running — mirroring
-     * XState, where stopping a never-started or already-stopped actor is a
-     * no-op with zero teardown — so paired cleanup never runs twice, nor
-     * against resources `onStart` never acquired. Stopping does not close the
-     * actor for good: a later `start()` is a fresh lifecycle and fires
-     * `onStart` again.
+     * The method fires `onStop` only when the actor ran. This matches XState, where a
+     * stop of an actor that never started, or of an actor that stopped already, does
+     * nothing and tears nothing down. Therefore the paired cleanup runs never two
+     * times, and it runs never against a resource that `onStart` did not take. A stop
+     * does not close the actor for ever: a later `start()` is a new lifecycle, and it
+     * fires `onStart` again.
      */
     stop(): this;
     /**
-     * Send an event to this actor.
+     * Sends an event to this actor.
      *
-     * The actor's state machine guards decide whether the event causes a transition.
-     * Pass any event from the machine's event union — domain events, routing events, etc.
+     * The guards of the state machine of the actor decide if the event causes a
+     * transition. Give any event of the event union of the machine: a domain event, a
+     * routing event, and so on.
      *
-     * @param event - An event from the machine's `EventFromLogic<TMachine>` union.
+     * @param event - An event of the `EventFromLogic<TMachine>` union of the machine.
      *
-     * @throws {InvalidEventError} When `event` is not a plain object (`null`, `undefined`,
-     *   a string, number, etc.). Import the class from `@xmachines/play-xstate/errors`.
+     * @throws {InvalidEventError} When `event` is not a plain object, for example
+     *   `null`, `undefined`, a string, or a number. Import the class from
+     *   `@xmachines/play-xstate/errors`.
      *
      * @example
      * ```typescript
-     * // Domain event (typed to machine's event union)
+     * // A domain event, with the type of the event union of the machine
      * actor.send({ type: "auth.login", userId: "123" });
      *
-     * // Routing event
+     * // A routing event
      * actor.send({ type: "play.route", to: "#home" });
      * ```
      */
     send(event: EventFromLogic<TMachine>): void;
     /**
-     * Get current snapshot
+     * Returns the current snapshot
      */
     getSnapshot(): ReturnType<Actor<TMachine>["getSnapshot"]>;
     /**
-     * Subscribe to this actor's snapshot updates.
+     * Subscribes to the snapshot updates of this actor.
      *
-     * Accepts an observer object, exactly like XState's `Actor.subscribe`.
+     * The method accepts an observer object, exactly like `Actor.subscribe` of XState.
      *
-     * @param observer - Observer with `next`/`error`/`complete` handlers.
-     * @returns Subscription with an `unsubscribe()` method.
+     * @param observer - The observer, with a `next`, an `error`, and a `complete` handler.
+     * @returns The subscription, with an `unsubscribe()` method.
      */
     subscribe(observer: Observer<SnapshotFrom<TMachine>>): Subscription;
     /**
-     * Subscribe to this actor's snapshot updates.
+     * Subscribes to the snapshot updates of this actor.
      *
-     * Accepts listener functions, exactly like XState's `Actor.subscribe`.
+     * The method accepts listener functions, exactly like `Actor.subscribe` of XState.
      *
-     * @param nextListener - Snapshot listener function.
-     * @param errorListener - Called when the actor errors.
-     * @param completeListener - Called when the actor completes (reaches a final state).
-     * @returns Subscription with an `unsubscribe()` method.
+     * @param nextListener - The listener function of each snapshot.
+     * @param errorListener - The actor calls it on an error.
+     * @param completeListener - The actor calls it when it completes, which means that it reaches a final state.
+     * @returns The subscription, with an `unsubscribe()` method.
      */
     subscribe(nextListener?: (snapshot: SnapshotFrom<TMachine>) => void, errorListener?: (error: unknown) => void, completeListener?: () => void): Subscription;
     /**
-     * Listen for events this actor emits via the `emit` action.
+     * Listens for the events that this actor emits with the `emit` action.
      *
-     * @param type - Emitted event type to listen for, or `"*"` for all.
-     * @param handler - Called with each matching emitted event.
-     * @returns Subscription with an `unsubscribe()` method.
+     * @param type - The type of the emitted event to listen for, or `"*"` for every event.
+     * @param handler - The actor calls it with each emitted event that matches.
+     * @returns The subscription, with an `unsubscribe()` method.
      */
     on<TType extends EmittedFrom<TMachine>["type"] | "*">(type: TType, handler: (emitted: EmittedFrom<TMachine> & (TType extends "*" ? unknown : {
         type: TType;
     })) => void): Subscription;
     /**
-     * Get this actor's persisted snapshot.
+     * Returns the persisted snapshot of this actor.
      *
-     * Suitable for serialization and later restoration via the factory's
-     * `restore.snapshot` option.
+     * Use it to serialize the state, and to restore it later with the
+     * `restore.snapshot` option of the factory.
      */
     getPersistedSnapshot(options?: unknown): Snapshot<unknown>;
     /**
-     * Derive and cache the view at state entry — once per transition, stored in
-     * the signal rather than recomputed per read.
+     * Derives the view at the entry of a state, and keeps it. This happens one time for
+     * each transition. The signal holds the view, and the code computes it not on each
+     * read.
      *
-     * @param snapshot - Current XState snapshot
+     * @param snapshot - The current XState snapshot
      */
     private validateAndCacheView;
     /**
-     * Convenience dispose method for cleanup — an alias for {@link stop}.
+     * The dispose method, for the cleanup. It is the alias of {@link stop}.
+     *
+     * @deprecated Use {@link stop}. Will be removed in the next major.
      */
     dispose(): void;
 }

package/dist/player-actor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"player-actor.d.ts","sourceRoot":"","sources":["../src/player-actor.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAElB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACN,aAAa,EAGb,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAGjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAgFhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,qBAAa,WAAW,CAAC,QAAQ,SAAS,eAAe,CACxD,SAAQ,aAAa,CAAC,aAAa,EAAE,cAAc,CAAC,QAAQ,CAAC,CAC7D,YAAW,QAAQ,EAAE,QAAQ;IAE7B,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD;;;;;;;;OAQG;IACH,QAAgB,WAAW,CAAC,CAAU;IACtC;;;;;;;;;;;;;;;OAeG;IACH,OAAO,KAAK,KAAK,GAEhB;IACD;;;;OAIG;IACH,QAAgB,SAAS,CAAC,CAAoC;IAC9D;;;;;;OAMG;IACH,QAAgB,qBAAqB,CAAC,CAAS;IAC/C;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB,CAA6C;IAG9D,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAE/D;;;;;;;;;;OAUG;IACI,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,OAAO;IAUpD;;;;;;;;;;;;;;;;OAgBG;IACI,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAEpD;;;;;;;;;;;;;;OAcG;IACH,SAAgB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,SAAgB,WAAW,gCAA2C;gBAGrE,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,EAChC,KAAK,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,EAC3B,gBAAgB,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC;IAwGtD;;;;;;;;OAQG;IACM,KAAK,IAAI,IAAI;IAoBtB;;;;;;;;;OASG;IACM,IAAI,IAAI,IAAI;IAsBrB;;;;;;;;;;;;;;;;;;;OAmBG;IACM,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,IAAI;IAmCpD;;OAEG;IACM,WAAW,IAAI,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,aAAa,CAAC,CAAC;IAgBlE;;;;;;;OAOG;IACM,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,YAAY;IAC5E;;;;;;;;;OASG;IACM,SAAS,CACjB,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,KAAK,IAAI,EACzD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EACxC,gBAAgB,CAAC,EAAE,MAAM,IAAI,GAC3B,YAAY;IAyCf;;;;;;OAMG;IACM,EAAE,CAAC,KAAK,SAAS,WAAW,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,GAAG,EAC5D,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,CACR,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,GAAG,OAAO,GAAG;QAAE,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC,KAC5E,IAAI,GACP,YAAY;IAIf;;;;;OAKG;IACM,oBAAoB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;IAKnE;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAqC5B;;OAEG;IACH,OAAO,IAAI,IAAI;CAGf"}
+{"version":3,"file":"player-actor.d.ts","sourceRoot":"","sources":["../src/player-actor.ts"],"names":[],"mappings":"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"}