@xmachines/play-xstate 1.0.0-beta.1

package/dist/guards/helpers.d.ts

@@ -0,0 +1,60 @@
+import type { Guard } from "./types.js";
+/**
+ * Check if context has a truthy value at path
+ *
+ * Per CONTEXT.md: Convenience helper for common guard pattern
+ *
+ * @example
+ * ```typescript
+ * const machine = setup({
+ *   guards: {
+ *     hasUserId: hasContext('userId'),
+ *     hasEmail: hasContext('user.email')
+ *   }
+ * });
+ * ```
+ *
+ * @param path - Dot-separated path to context property
+ * @returns Guard predicate checking if property is truthy
+ */
+export declare const hasContext: <TContext = any>(path: string) => Guard<TContext, any>;
+/**
+ * Check if event type matches expected type
+ *
+ * @example
+ * ```typescript
+ * const machine = setup({
+ *   guards: {
+ *     isSubmitEvent: eventMatches('submit'),
+ *     isBackOrForward: composeGuardsOr([
+ *       eventMatches('back'),
+ *       eventMatches('forward')
+ *     ])
+ *   }
+ * });
+ * ```
+ *
+ * @param eventType - Expected event type
+ * @returns Guard predicate checking event type
+ */
+export declare const eventMatches: <TEvent extends {
+    type: string;
+} = any>(eventType: string) => Guard<any, TEvent>;
+/**
+ * Check if current state matches expected value
+ *
+ * @example
+ * ```typescript
+ * const machine = setup({
+ *   guards: {
+ *     isLoggedIn: stateMatches('authenticated'),
+ *     isDashboard: stateMatches('authenticated.dashboard')
+ *   }
+ * });
+ * ```
+ *
+ * @param stateValue - Expected state value (string or object)
+ * @returns Guard predicate checking state value
+ */
+export declare const stateMatches: <TContext = any>(stateValue: string) => Guard<TContext, any>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/guards/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/guards/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,GAAG,GAAG,EAAE,MAAM,MAAM,KAAG,KAAK,CAAC,QAAQ,EAAE,GAAG,CAIlD,CAAC;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,GAAG,EAAE,WAAW,MAAM,KAAG,KAAK,CAAC,GAAG,EAAE,MAAM,CAG5E,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,GACvB,QAAQ,GAAG,GAAG,EAAE,YAAY,MAAM,KAAG,KAAK,CAAC,QAAQ,EAAE,GAAG,CAexD,CAAC"}

package/dist/guards/helpers.js

@@ -0,0 +1,91 @@
+/**
+ * Check if context has a truthy value at path
+ *
+ * Per CONTEXT.md: Convenience helper for common guard pattern
+ *
+ * @example
+ * ```typescript
+ * const machine = setup({
+ *   guards: {
+ *     hasUserId: hasContext('userId'),
+ *     hasEmail: hasContext('user.email')
+ *   }
+ * });
+ * ```
+ *
+ * @param path - Dot-separated path to context property
+ * @returns Guard predicate checking if property is truthy
+ */
+export const hasContext = (path) => ({ context }) => {
+    const value = getNestedValue(context, path);
+    return value !== undefined && value !== null && value !== "";
+};
+/**
+ * Check if event type matches expected type
+ *
+ * @example
+ * ```typescript
+ * const machine = setup({
+ *   guards: {
+ *     isSubmitEvent: eventMatches('submit'),
+ *     isBackOrForward: composeGuardsOr([
+ *       eventMatches('back'),
+ *       eventMatches('forward')
+ *     ])
+ *   }
+ * });
+ * ```
+ *
+ * @param eventType - Expected event type
+ * @returns Guard predicate checking event type
+ */
+export const eventMatches = (eventType) => ({ event }) => {
+    return event.type === eventType;
+};
+/**
+ * Check if current state matches expected value
+ *
+ * @example
+ * ```typescript
+ * const machine = setup({
+ *   guards: {
+ *     isLoggedIn: stateMatches('authenticated'),
+ *     isDashboard: stateMatches('authenticated.dashboard')
+ *   }
+ * });
+ * ```
+ *
+ * @param stateValue - Expected state value (string or object)
+ * @returns Guard predicate checking state value
+ */
+export const stateMatches = (stateValue) => ({ context }) => {
+    // Note: This helper checks context for state info
+    // For actual XState state matching, use machine.matches() in actions
+    // This is a simplified version for context-based state checks
+    const currentState = context._state || context.state;
+    if (!currentState)
+        return false;
+    // Simple string matching (can be enhanced for nested states)
+    if (typeof currentState === "string") {
+        return currentState === stateValue;
+    }
+    // Object state matching
+    return JSON.stringify(currentState).includes(stateValue);
+};
+/**
+ * Get nested value from object using dot-separated path
+ *
+ * @internal
+ */
+const getNestedValue = (obj, path) => {
+    const keys = path.split(".");
+    let value = obj;
+    for (const key of keys) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        value = value[key];
+    }
+    return value;
+};
+//# sourceMappingURL=helpers.js.map

package/dist/guards/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/guards/helpers.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,UAAU,GACtB,CAAiB,IAAY,EAAwB,EAAE,CACvD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACf,MAAM,KAAK,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC5C,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;AAC9D,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,YAAY,GACxB,CAAwC,SAAiB,EAAsB,EAAE,CACjF,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;IACb,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AACjC,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,YAAY,GACxB,CAAiB,UAAkB,EAAwB,EAAE,CAC7D,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACf,kDAAkD;IAClD,qEAAqE;IACrE,8DAA8D;IAC9D,MAAM,YAAY,GAAI,OAAe,CAAC,MAAM,IAAK,OAAe,CAAC,KAAK,CAAC;IACvE,IAAI,CAAC,YAAY;QAAE,OAAO,KAAK,CAAC;IAEhC,6DAA6D;IAC7D,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE,CAAC;QACtC,OAAO,YAAY,KAAK,UAAU,CAAC;IACpC,CAAC;IAED,wBAAwB;IACxB,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAC1D,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,cAAc,GAAG,CAAC,GAAQ,EAAE,IAAY,EAAO,EAAE;IACtD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,KAAK,GAAG,GAAG,CAAC;IAEhB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC3C,OAAO,SAAS,CAAC;QAClB,CAAC;QACD,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC,CAAC"}

package/dist/guards/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Guard composition and helper utilities for XState machines
+ *
+ * Provides array-means-AND composition and convenience helpers
+ * for common guard patterns in Play Architecture.
+ *
+ * @packageDocumentation
+ */
+export { composeGuards, composeGuardsOr, negateGuard } from "./compose.js";
+export { hasContext, eventMatches, stateMatches } from "./helpers.js";
+export type { Guard, GuardArray } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/guards/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACtE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/guards/index.js

@@ -0,0 +1,11 @@
+/**
+ * Guard composition and helper utilities for XState machines
+ *
+ * Provides array-means-AND composition and convenience helpers
+ * for common guard patterns in Play Architecture.
+ *
+ * @packageDocumentation
+ */
+export { composeGuards, composeGuardsOr, negateGuard } from "./compose.js";
+export { hasContext, eventMatches, stateMatches } from "./helpers.js";
+//# sourceMappingURL=index.js.map

package/dist/guards/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}

package/dist/guards/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Standard XState guard function signature
+ *
+ * Per CONTEXT.md: Guards receive { context, event } per XState standard
+ *
+ * @param args - Guard arguments with context and event
+ * @param args.context - Current machine context
+ * @param args.event - Event that triggered the guard evaluation
+ * @returns boolean indicating if guard passes
+ */
+export type Guard<TContext = any, TEvent = any> = (args: {
+    context: TContext;
+    event: TEvent;
+}) => boolean;
+/**
+ * Array of guard predicates or guard names
+ *
+ * Per CONTEXT.md: Array means AND - all guards must pass
+ */
+export type GuardArray<TContext = any, TEvent = any> = Array<Guard<TContext, TEvent>> | Array<string>;
+//# sourceMappingURL=types.d.ts.map

package/dist/guards/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/guards/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,CAAC,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE;IACxD,OAAO,EAAE,QAAQ,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACd,KAAK,OAAO,CAAC;AAEd;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,IAChD,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,GAC9B,KAAK,CAAC,MAAM,CAAC,CAAC"}

package/dist/guards/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/guards/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/guards/types.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @xmachines/play-xstate - XState v5 adapter for Play Architecture
+ *
+ * Provides definePlayer() API for binding XState state machines to the
+ * actor base with catalog binding, signal lifecycle, and DevTools integration.
+ *
+ * Per RFC Play v1, this package implements the Logic Layer adapter that
+ * transforms declarative machine definitions into live actors with signal-driven
+ * reactivity.
+ *
+ * @packageDocumentation
+ */
+export { definePlayer } from "./define-player.js";
+export { PlayerActor } from "./player-actor.js";
+export type { PlayerConfig, PlayerOptions, PlayerFactory } from "./types.js";
+export { composeGuards, composeGuardsOr, negateGuard, hasContext, eventMatches, stateMatches, } from "./guards/index.js";
+export type { Guard, GuardArray } from "./guards/types.js";
+export { deriveRoute, isAbsoluteRoute, buildRouteUrl, formatPlayRouteTransitions, } from "./routing/index.js";
+export type { RouteMetadata, RouteObject, RouteContext } from "./routing/types.js";
+export { validateComponentBinding, validateViewProps, mergeViewProps } from "./catalog/index.js";
+export type { Catalog, CatalogEntry, ViewMetadata } from "./catalog/types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG7E,OAAO,EACN,aAAa,EACb,eAAe,EACf,WAAW,EACX,UAAU,EACV,YAAY,EACZ,YAAY,GACZ,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG3D,OAAO,EACN,WAAW,EACX,eAAe,EACf,aAAa,EACb,0BAA0B,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGnF,OAAO,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACjG,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * @xmachines/play-xstate - XState v5 adapter for Play Architecture
+ *
+ * Provides definePlayer() API for binding XState state machines to the
+ * actor base with catalog binding, signal lifecycle, and DevTools integration.
+ *
+ * Per RFC Play v1, this package implements the Logic Layer adapter that
+ * transforms declarative machine definitions into live actors with signal-driven
+ * reactivity.
+ *
+ * @packageDocumentation
+ */
+export { definePlayer } from "./define-player.js";
+export { PlayerActor } from "./player-actor.js";
+// Guard utilities
+export { composeGuards, composeGuardsOr, negateGuard, hasContext, eventMatches, stateMatches, } from "./guards/index.js";
+// Routing utilities
+export { deriveRoute, isAbsoluteRoute, buildRouteUrl, formatPlayRouteTransitions, } from "./routing/index.js";
+// Catalog utilities
+export { validateComponentBinding, validateViewProps, mergeViewProps } from "./catalog/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,kBAAkB;AAClB,OAAO,EACN,aAAa,EACb,eAAe,EACf,WAAW,EACX,UAAU,EACV,YAAY,EACZ,YAAY,GACZ,MAAM,mBAAmB,CAAC;AAG3B,oBAAoB;AACpB,OAAO,EACN,WAAW,EACX,eAAe,EACf,aAAa,EACb,0BAA0B,GAC1B,MAAM,oBAAoB,CAAC;AAG5B,oBAAoB;AACpB,OAAO,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/player-actor.d.ts

@@ -0,0 +1,143 @@
+import { type AnyStateMachine, type AnyActorLogic } from "xstate";
+import { AbstractActor, type Routable, type Viewable } from "@xmachines/play-actor";
+import { Signal } from "@xmachines/play-signals";
+import type { PlayEvent } from "@xmachines/play";
+import type { PlayerOptions } from "./types.js";
+/**
+ * Concrete XState actor implementing Play Architecture signal protocol
+ *
+ * Extends {@link @xmachines/play-actor!AbstractActor} to provide XState v5 integration
+ * while maintaining ecosystem compatibility (XState inspection, devtools). This actor
+ * wraps an internal XState actor and exposes TC39 Signal-based reactive state for
+ * Infrastructure observation.
+ *
+ * **Capabilities:** Implements both {@link @xmachines/play-actor!Routable} and
+ * {@link @xmachines/play-actor!Viewable} interfaces, providing routing and view
+ * rendering support.
+ *
+ * **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.
+ *
+ * @typeParam TMachine - XState v5 state machine type
+ *
+ * @example
+ * Basic actor creation and lifecycle
+ * ```typescript
+ * import { setup } from "xstate";
+ * import { definePlayer } from "@xmachines/play-xstate";
+ *
+ * const machine = setup({}).createMachine({
+ *   initial: 'idle',
+ *   states: {
+ *     idle: {
+ *       meta: { route: '/', view: { component: 'HomePage' } }
+ *     }
+ *   }
+ * });
+ *
+ * const createPlayer = definePlayer({ machine });
+ * const actor = createPlayer();
+ * actor.start();
+ *
+ * // Observe signals
+ * console.log(actor.currentRoute.get()); // '/'
+ * console.log(actor.currentView.get());  // { component: 'HomePage' }
+ * ```
+ *
+ * @example
+ * Signal lifecycle with watchers (microtask batching)
+ * ```typescript
+ * import { Signal } from "@xmachines/play-signals";
+ *
+ * const watcher = new Signal.subtle.Watcher(() => {
+ *   queueMicrotask(() => {
+ *     const pending = watcher.getPending();
+ *     console.log('State changed:', actor.state.get());
+ *   });
+ * });
+ *
+ * watcher.watch(actor.state);
+ * actor.send({ type: 'play.route', to: '#about' });
+ * // Watcher notification scheduled via microtask
+ * ```
+ *
+ * @see {@link https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md | RFC Play v1}
+ * @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
+ *
+ * @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.
+ *
+ * **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.
+ */
+export declare class PlayerActor<TMachine extends AnyStateMachine> extends AbstractActor<AnyActorLogic> implements Routable, Viewable, Record<string, any> {
+    private _xstateActor;
+    private _stateManager;
+    private _options;
+    private _catalog;
+    private _viewSignal;
+    state: Signal.State<any>;
+    currentRoute: Signal.Computed<string | null>;
+    currentView: Signal.State<{
+        component: string;
+        props: any;
+    } | null>;
+    catalog: any;
+    constructor(machine: TMachine, catalog: any, options: PlayerOptions, input?: any);
+    /**
+     * Start the actor
+     *
+     * Per RESEARCH.md Pitfall 1: Always call start() after creation
+     */
+    start(): this;
+    /**
+     * Stop the actor and cleanup
+     */
+    stop(): this;
+    /**
+     * Send event to actor
+     *
+     * Forwards events to the underlying XState actor. The actor's state machine
+     * guards determine whether each event is valid from the current state.
+     *
+     * @param event - Any event object with a type property
+     *
+     * @example
+     * ```typescript
+     * // Domain event
+     * actor.send({ type: 'auth.login', userId: '123' });
+     *
+     * // Routing event
+     * actor.send({ type: 'play.route', to: '#home' });
+     * ```
+     */
+    send(event: PlayEvent): void;
+    /**
+     * Get current snapshot
+     */
+    getSnapshot(): any;
+    /**
+     * Validate view at state entry and cache result
+     *
+     * Per CONTEXT.md: "Prop validation: At state entry (when state becomes active)"
+     * Validates once per transition and stores result in signal.
+     *
+     * @param snapshot - Current XState snapshot
+     */
+    private _validateAndCacheView;
+    /**
+     * Convenience dispose method for cleanup
+     *
+     * Per CONTEXT.md: "Both .dispose() convenience method and manual machine.stop()"
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=player-actor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"player-actor.d.ts","sourceRoot":"","sources":["../src/player-actor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,eAAe,EAAc,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC3F,OAAO,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACpF,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAKhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,qBAAa,WAAW,CAAC,QAAQ,SAAS,eAAe,CACxD,SAAQ,aAAa,CAAC,aAAa,CACnC,YAAW,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAElD,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,WAAW,CAAyD;IAGrE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC7C,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACpE,OAAO,EAAE,GAAG,CAAC;gBAER,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,GAAG;IA+EhF;;;;OAIG;IACM,KAAK,IAAI,IAAI;IAWtB;;OAEG;IACM,IAAI,IAAI,IAAI;IAYrB;;;;;;;;;;;;;;;;OAgBG;IACM,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAsBrC;;OAEG;IACM,WAAW,IAAI,GAAG;IAI3B;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAwE7B;;;;OAIG;IACH,OAAO,IAAI,IAAI;CAGf"}