@alwatr/action 9.26.0 → 9.28.0

package/README.md

@@ -2,7 +2,9 @@
 
 **Declarative DOM action-dispatch — the Action layer for Unidirectional Data Flow.**
 
-`@alwatr/action` bridges HTML `on-<eventType>` attributes to typed signal handlers using **global event delegation**. One listener on `document.body` covers every element on the page — including elements added dynamically after bootstrap — with O(1) initialization cost regardless of how many elements exist.
+`@alwatr/action` bridges HTML `on-<eventType>` attributes to typed signal handlers using **global event delegation**. It is implemented as a factory service (`ActionService`) with all state and listeners encapsulated. A pre-instantiated singleton `actionService` is exported for immediate use.
+
+One listener on `document.body` covers every element on the page — including elements added dynamically after bootstrap — with O(1) initialization cost regardless of how many elements exist.
 
 ---
 
@@ -40,7 +42,7 @@ document.body capture listener  (1 listener per event type)
            parse attribute → 'ui_add_to_cart:42'
            run modifiers   → none
            resolve payload → '42'
-           internalChannel_.dispatch('ui_add_to_cart', {
+           actionService.dispatch({
              type: 'ui_add_to_cart',
              payload: '42',
              context: 'product-list',
@@ -99,15 +101,24 @@ declare module '@alwatr/action' {
 
 ### 2. Bootstrap delegation
 
+Use the pre-instantiated singleton `actionService`:
+
 ```ts
-import {setupActionDelegation, onAction} from '@alwatr/action';
+import {actionService} from '@alwatr/action';
 import './action-record.js'; // ensure the declaration is loaded
 
-setupActionDelegation();
+// Initialize global event delegation
+actionService.setupDelegation();
 
 // The handler receives the full Action<K> object — payload, context, and meta in one place.
-onAction('ui_open_drawer', (action) => openDrawer(action.payload)); // action.payload: string
-onAction('ui_add_to_cart', (action) => {
+actionService.on('ui_open_drawer', (action) => openDrawer(action.payload)); // action.payload: string
+
+// Subscribe to multiple action types using an array
+actionService.on(['ui_open_drawer', 'ui_close_drawer'], (action) => {
+  console.log(action.type, action.payload);
+});
+
+actionService.on('ui_add_to_cart', (action) => {
   cartService.add(action.payload.productId, action.payload.qty); // fully typed
   console.log(action.context); // e.g. 'product-list' — from nearest [action-context] ancestor
 });
@@ -167,7 +178,7 @@ Wrap a group of elements in an `[action-context]` container to scope their actio
 ```
 
 ```ts
-onAction('ui_slider_change', (action) => {
+actionService.on('ui_slider_change', (action) => {
   if (action.context === 'volume') audioService.setVolume(Number(action.payload));
   if (action.context === 'brightness') displayService.setBrightness(Number(action.payload));
 });
@@ -177,20 +188,20 @@ Context is `undefined` when no `[action-context]` ancestor exists — programmat
 
 ### 5. Programmatic dispatch
 
-Use `dispatchAction` for code-originated actions (after async operations, from services, etc.).
+Use `actionService.dispatch` for code-originated actions (after async operations, from services, etc.).
 These actions should **not** use the `ui_` prefix — that prefix is reserved for DOM-originated actions.
 
 ```ts
-import {dispatchAction} from '@alwatr/action';
+import {actionService} from '@alwatr/action';
 
 // Code-originated actions — no 'ui_' prefix
 await uploadFile(file);
-dispatchAction({type: 'upload_complete', payload: fileId});
+actionService.dispatch({type: 'upload_complete', payload: fileId});
 
-dispatchAction({type: 'navigate', payload: '/dashboard'});
+actionService.dispatch({type: 'navigate', payload: '/dashboard'});
 
 // With explicit context and meta
-dispatchAction({
+actionService.dispatch({
   type: 'slider_change',
   payload: 75,
   context: 'volume',
@@ -260,10 +271,10 @@ interface Action<K extends keyof ActionRecord> {
 Modifiers in the delegation pipeline receive the mutable `action` object and can enrich `meta` before the action reaches subscribers:
 
 ```ts
-import {registerModifier} from '@alwatr/action';
+import {actionService} from '@alwatr/action';
 
 // A modifier that stamps a trace ID into meta
-registerModifier('trace', (_event, _element, action) => {
+actionService.registerModifier('trace', (_event, _element, action) => {
   action.meta ??= {};
   action.meta['traceId'] = crypto.randomUUID();
   return true;
@@ -275,7 +286,7 @@ registerModifier('trace', (_event, _element, action) => {
 ```
 
 ```ts
-onAction('ui_submit_order', (action) => {
+actionService.on('ui_submit_order', (action) => {
   console.log(action.meta?.['traceId']); // e.g. 'a1b2-c3d4-…'
 });
 ```
@@ -284,182 +295,101 @@ onAction('ui_submit_order', (action) => {
 
 ## API Reference
 
-### `Action<K>` (interface)
+### `actionService` (Singleton instance of `ActionService`)
 
-The Alwatr Flux Standard Action object. Every dispatch and every handler callback uses this structure.
+The pre-instantiated factory service exported for standard usage.
 
-```ts
-import type {Action} from '@alwatr/action';
-
-// Reading fields in a handler
-onAction('ui_add_to_cart', (action: Action<'ui_add_to_cart'>) => {
-  console.log(action.type); // 'ui_add_to_cart'
-  console.log(action.payload); // {productId: number; qty: number}
-  console.log(action.context); // string | undefined
-  console.log(action.meta); // Record<string, unknown> | undefined
-});
-```
+#### `actionService.on(type, handler)`
 
----
+Subscribes to a single action or an array of actions. O(1) routing via `ChannelSignal`.
 
-### `ActionRecord` (interface)
+```ts
+actionService.on<K extends keyof ActionRecord>(
+  type: K | K[],
+  handler: (action: Action<K>) => Awaitable<void>
+): SubscribeResult;
 
-The global action type registry. Extend via declaration merging to register typed actions.
+// Usage:
+// Subscribe to a single action
+actionService.on('ui_open_drawer', (action) => { ... });
 
-```ts
-declare module '@alwatr/action' {
-  interface ActionRecord {
-    ui_open_drawer: string;
-    ui_logout: void;
-  }
-}
+// Subscribe to multiple action types
+actionService.on(['ui_open_drawer', 'ui_close_drawer'], (action) => { ... });
 ```
 
----
-
-### `setupActionDelegation(eventTypes?)`
+#### `actionService.dispatch(action)`
 
-Registers global event delegation on `document.body`. Call once at bootstrap. Idempotent.
+Dispatches an action to all subscribers.
 
 ```ts
-function setupActionDelegation(eventTypes?: readonly string[]): void;
-```
-
-Defaults to `DEFAULT_DELEGATED_EVENTS`: `['click', 'submit', 'input', 'change']`.
+actionService.dispatch<K extends keyof ActionRecord>(action: DispatchParam<K>): void;
 
-```ts
-import {setupActionDelegation, DEFAULT_DELEGATED_EVENTS} from '@alwatr/action';
+// Usage:
+// Dispatch a typed action (payload is required)
+actionService.dispatch({type: 'upload_complete', payload: 'file-123'});
 
-setupActionDelegation([...DEFAULT_DELEGATED_EVENTS, 'keydown']);
+// Dispatch a void action (payload can be omitted)
+actionService.dispatch({type: 'auth_expired'});
 ```
 
----
-
-### `teardownActionDelegation()`
+#### `actionService.setupDelegation(eventTypes?)`
 
-Removes all delegation listeners and clears the descriptor cache. Useful in tests or micro-frontend teardown.
+Registers global capture listeners on `document.body`. Defaults to `['click', 'submit', 'input', 'change']`.
 
 ```ts
-function teardownActionDelegation(): void;
+actionService.setupDelegation(eventTypes?: readonly string[]): void;
 ```
 
----
+#### `actionService.teardownDelegation()`
 
-### `onAction(type, handler)`
-
-Subscribes to a single named action or an array of actions. O(1) routing via `ChannelSignal`. The handler receives the full `Action<K>` object.
+Unregisters all delegation listeners and clears the descriptor cache.
 
 ```ts
-function onAction<K extends keyof ActionRecord>(
-  type: K | K[],
-  handler: (action: Action<K>) => Awaitable<void>,
-): SubscribeResult;
+actionService.teardownDelegation(): void;
 ```
 
-```ts
-// Subscribe to a single action
-const sub = onAction('ui_open_drawer', (action) => {
-  openDrawer(action.payload); // payload: string
-  console.log(action.context); // e.g. 'sidebar' or undefined
-});
+#### `actionService.registerModifier(name, handler)`
 
-// Subscribe to multiple actions with a single handler
-const multiSub = onAction(['ui_increment', 'ui_decrement'], (action) => {
-  console.log('Action triggered:', action.type);
-});
-
-sub.unsubscribe(); // prevent memory leaks
-multiSub.unsubscribe();
-```
-
----
-
-### `dispatchAction(action)`
-
-Dispatches a named action. Payload type is enforced by `ActionRecord`.
+Registers custom modifiers.
 
 ```ts
-function dispatchAction<K extends keyof ActionRecord>(action: Action<K>): void;
+actionService.registerModifier(name: string, handler: ModifierHandler): void;
 ```
 
-```ts
-// With payload (code-originated — no 'ui_' prefix)
-dispatchAction({type: 'navigate', payload: 'settings'});
+#### `actionService.registerPayloadResolver(name, resolver)`
 
-// Void payload
-dispatchAction({type: 'auth_expired', payload: undefined});
+Registers custom payload resolvers.
 
-// With context and meta
-dispatchAction({
-  type: 'navigate',
-  payload: 'settings',
-  context: 'header',
-  meta: {triggeredBy: 'keyboard'},
-});
+```ts
+actionService.registerPayloadResolver(name: string, resolver: PayloadResolver): void;
 ```
 
 ---
 
-### `registerModifier(name, handler)`
-
-Registers a custom modifier. Return `false` to cancel the dispatch.
+### `ActionService` (Class)
 
-Handler signature: `(event: Event, element: HTMLElement, action: Action) => boolean`
-
-The handler receives the mutable `action` object and may write to `action.meta`.
+The class constructor, allowing creation of independent instances of the action bus and delegation pipeline if needed (e.g. in multi-app or test micro-environments).
 
 ```ts
-import {registerModifier} from '@alwatr/action';
-
-registerModifier('not_disabled', (_event, element) => {
-  return !(element as HTMLButtonElement).disabled;
-});
+import {ActionService} from '@alwatr/action';
 
-// A modifier that enriches meta before dispatch
-registerModifier('timestamp', (_event, _element, action) => {
-  action.meta ??= {};
-  action.meta['ts'] = Date.now();
-  return true;
-});
-```
-
-```html
-<button
-  on-click="ui_select_item:$data_id; not_disabled,timestamp"
-  data-id="42"
->
-  Select
-</button>
+const myService = new ActionService();
+myService.setupDelegation(['click']);
 ```
 
 ---
 
-### `registerPayloadResolver(name, resolver)`
+### Deprecated Global Functions (Backwards Compatibility)
 
-Registers a custom payload resolver.
+For backwards compatibility with previous versions, the following wrapper functions are exported. They delegate directly to the `actionService` singleton instance and are marked as **deprecated**.
 
-Handler signature: `(event: Event, element: HTMLElement) => unknown`
-
-```ts
-import {registerPayloadResolver} from '@alwatr/action';
-
-registerPayloadResolver('$data_id', (_event, element) => {
-  return (element as HTMLElement).dataset.id ?? null;
-});
-```
-
-```html
-<input
-  type="checkbox"
-  on-change="ui_toggle_feature:$checked"
-/>
-<li
-  on-click="ui_select_item:$data_id"
-  data-id="42"
->
-  Item
-</li>
-```
+- `onAction(type, handler)` (deprecated wrapper for `actionService.on`)
+- `dispatchAction(action)` (deprecated wrapper for `actionService.dispatch`)
+- `setupActionDelegation(eventTypes?)` (deprecated wrapper for `actionService.setupDelegation`)
+- `teardownActionDelegation()` (deprecated wrapper for `actionService.teardownDelegation`)
+- `registerModifier(name, handler)` (deprecated wrapper for `actionService.registerModifier`)
+- `registerPayloadResolver(name, resolver)` (deprecated wrapper for `actionService.registerPayloadResolver`)
+- `DEFAULT_DELEGATED_EVENTS` (constant mapped to `ActionService.DEFAULT_DELEGATED_EVENTS`)
 
 ---
 
@@ -472,8 +402,8 @@ registerPayloadResolver('$data_id', (_event, element) => {
 │    <button on-click="ui_add_to_cart:42">Add</button>       │
 │  </section>                                                │
 └─────────────────────────┬──────────────────────────────────┘
-                          │ DOM event bubbles to body
-                          ▼
+                           │ DOM event bubbles to body
+                           ▼
 ┌────────────────────────────────────────────────────────────┐
 │                 Action Layer (@alwatr/action)              │
 │  document.body capture listener (1 per event type)         │
@@ -481,26 +411,26 @@ registerPayloadResolver('$data_id', (_event, element) => {
 │  → closest('[action-context]') → context = 'cart'          │
 │  → run modifiers (may enrich action.meta)                  │
 │  → resolve payload → '42'                                  │
-│  → dispatch Action {type, payload, context, meta}  [O(1)]  │
+│  → actionService.dispatch(Action)                   [O(1)] │
 └─────────────────────────┬──────────────────────────────────┘
-                          │ O(1) routing via ChannelSignal
-                          ▼
+                           │ O(1) routing via ChannelSignal
+                           ▼
 ┌────────────────────────────────────────────────────────────┐
 │                     Business Logic Layer                   │
-│  onAction('ui_add_to_cart', (action) => {                  │
+│  actionService.on('ui_add_to_cart', (action) => {          │
 │    cartService.add(action.payload);                        │
 │    // action.context === 'cart'                            │
 │  })                                                        │
 └─────────────────────────┬──────────────────────────────────┘
-                          │ state update
-                          ▼
+                           │ state update
+                           ▼
 ┌────────────────────────────────────────────────────────────┐
 │                   State Layer (@alwatr/signal)             │
 │  cartSignal.set(newCartState)                              │
 └─────────────────────────┬──────────────────────────────────┘
-                          │ state flows down to UI
-                          ▼
-                     UI re-renders
+                           │ state flows down to UI
+                           ▼
+                      UI re-renders
 ```
 
 ---
@@ -555,60 +485,25 @@ onAction('ui_add_to_cart', (action) => {
 });
 ```
 
-### `registerModifier` handler signature changed
-
-Modifier handlers now receive a third `action` argument for `meta` enrichment.
-
-**Before:**
-
-```ts
-registerModifier('not_disabled', (_event, element) => {
-  return !(element as HTMLButtonElement).disabled;
-});
-```
-
-**After (backward-compatible — third arg is optional to use):**
+### Automated AI Migration Prompt
 
-```ts
-registerModifier('not_disabled', (_event, element, _action) => {
-  return !(element as HTMLButtonElement).disabled;
-});
-```
+If you are using an AI coding assistant (like Cursor, Gemini, Copilot, or Antigravity) to migrate your files to the new `actionService` API, you can use the following prompt to automate the refactoring:
 
-### Attribute syntax changed
-
-The event type is now encoded in the **attribute name** instead of the value, and modifiers are listed after a semicolon instead of dot-chained before the arrow.
-
-**Before:**
+```text
+Refactor this file to migrate from the deprecated global `@alwatr/action` (or `@alwatr/flux`) functions to the new `actionService` singleton API.
 
-```html
-<button on-action="click->ui_open_drawer:main">Open</button>
-<form
-  on-action="submit.prevent.validate->ui_submit_form:$formdata"
-  novalidate
->
-  …
-</form>
-<button on-action="click.once->ui_welcome_dismissed">Got it</button>
+Follow these rules:
+1. Replace imports of `onAction`, `dispatchAction`, `setupActionDelegation`, `teardownActionDelegation`, `registerModifier`, or `registerPayloadResolver` from `@alwatr/action` (or `@alwatr/flux`) with `actionService`.
+2. Convert all calls:
+   - `onAction(...)` ➔ `actionService.on(...)`
+   - `dispatchAction(...)` ➔ `actionService.dispatch(...)`
+   - `setupActionDelegation(...)` ➔ `actionService.setupDelegation(...)`
+   - `teardownActionDelegation(...)` ➔ `actionService.teardownDelegation(...)`
+   - `registerModifier(...)` ➔ `actionService.registerModifier(...)`
+   - `registerPayloadResolver(...)` ➔ `actionService.registerPayloadResolver(...)`
+3. Maintain exact type safety, callback parameter types, and business logic.
 ```
 
-**After:**
-
-```html
-<button on-click="ui_open_drawer:main">Open</button>
-<form
-  on-submit="ui_submit_form:$formdata; prevent,validate"
-  novalidate
->
-  …
-</form>
-<button on-click="ui_welcome_dismissed; once">Got it</button>
-```
-
-### `page-ready` moved to `@alwatr/page-ready`
-
-`dispatchPageId` / `onPageReady` are no longer part of this package.
-
 ---
 
 ## 🌊 Part of Alwatr Flux
@@ -620,7 +515,7 @@ View (HTML on-<event> attributes + action-context)
   ↓
 Action Layer (@alwatr/action) — global delegation, O(1) routing, AFSA objects
   ↓
-Controller (business logic via onAction — receives full Action object)
+Controller (business logic via actionService.on — receives full Action object)
   ↓
 State Layer (@alwatr/signal) — fine-grained reactivity
   ↓
@@ -633,10 +528,10 @@ View (re-render only affected nodes)
 
 ```typescript
 // Use @alwatr/flux for the complete architecture
-import {setupActionDelegation, onAction, createStateSignal} from '@alwatr/flux';
+import {actionService, createStateSignal} from '@alwatr/flux';
 
 // Or use @alwatr/action standalone for just the action bus
-import {setupActionDelegation, onAction, dispatchAction} from '@alwatr/action';
+import {actionService} from '@alwatr/action';
 ```
 
 → [View the complete Flux documentation](https://github.com/Alwatr/alwatr/tree/next/pkg/flux)

package/dist/action-service.d.ts

@@ -0,0 +1,178 @@
+import type { SubscribeResult } from '@alwatr/signal';
+import type { Awaitable } from '@alwatr/type-helper';
+import type { Action, ActionRecord, DispatchParam, ModifierHandler, PayloadResolver } from './type.js';
+/**
+ * Parsed representation of an action attribute descriptor.
+ * @internal
+ */
+interface ActionDescriptor {
+    readonly modifiers: ReadonlySet<string>;
+    readonly actionId: string;
+    readonly payload: string | undefined;
+}
+/**
+ * Service to manage declarative DOM actions, programmatic dispatch,
+ * modifiers, payload resolvers, and global event delegation.
+ *
+ * @example
+ * ```ts
+ * import {ActionService} from '@alwatr/action';
+ *
+ * const customActionService = new ActionService();
+ * ```
+ */
+export declare class ActionService {
+    /**
+     * Default DOM event types that cover the vast majority of interactive elements.
+     */
+    static readonly DEFAULT_DELEGATED_EVENTS: readonly string[];
+    protected readonly logger_: import("@alwatr/logger").AlwatrLogger;
+    /**
+     * Internal ChannelSignal used for routing dispatched actions.
+     * @protected
+     */
+    protected readonly internalChannel_: import("@alwatr/signal").ChannelSignal<Record<string, Action<never>>>;
+    /**
+     * Registry mapping custom modifiers to their handlers.
+     * @protected
+     */
+    protected readonly modifierRegistry_: Map<string, ModifierHandler>;
+    /**
+     * Registry mapping custom payload resolvers to their functions.
+     * @protected
+     */
+    protected readonly payloadRegistry_: Map<string, PayloadResolver>;
+    /**
+     * Cache of parsed action descriptors to prevent redundant regex evaluation.
+     * @protected
+     */
+    protected readonly descriptorCache_: Map<string, ActionDescriptor | null>;
+    /**
+     * Tracked event types currently delegated to `document.body`.
+     * @protected
+     */
+    protected readonly delegatedEventTypes_: Set<string>;
+    /**
+     * Bound delegation handler for add/removeEventListener.
+     * @private
+     */
+    private readonly handleDelegatedEventBound__;
+    constructor();
+    /**
+     * Subscribes to a named action dispatched anywhere in the application.
+     *
+     * @template K - A key of ActionRecord.
+     * @param type    - Action type or array of action types to subscribe to.
+     * @param handler - Callback invoked with the full Action object.
+     * @returns SubscribeResult containing an `unsubscribe` method.
+     *
+     * @example
+     * ```ts
+     * // Subscribe to a single action
+     * const sub1 = actionService.on('ui_open_drawer', (action) => {
+     *   console.log(action.payload);
+     * });
+     *
+     * // Subscribe to multiple action types
+     * const sub2 = actionService.on(['ui_open_drawer', 'ui_close_drawer'], (action) => {
+     *   console.log(action.type, action.payload);
+     * });
+     * ```
+     */
+    on<K extends keyof ActionRecord>(type: K | K[], handler: (action: Action<K>) => Awaitable<void>): SubscribeResult;
+    /**
+     * Dispatches an action to all subscribers matching `action.type`.
+     *
+     * @template K - A key of ActionRecord.
+     * @param action - Action object containing `type` and `payload`.
+     *
+     * @example
+     * ```ts
+     * // Dispatches a typed action (payload is required)
+     * actionService.dispatch({type: 'upload_complete', payload: 'file-123'});
+     *
+     * // Dispatches a void action (payload can be omitted)
+     * actionService.dispatch({type: 'auth_expired'});
+     * ```
+     */
+    dispatch<K extends keyof ActionRecord>(action: DispatchParam<K>): void;
+    /**
+     * Registers a custom modifier to enrich or filter actions before dispatch.
+     *
+     * @param name    - Modifier name (lowercase, alphanumeric).
+     * @param handler - Function called when modifier is invoked.
+     *
+     * @example
+     * ```ts
+     * actionService.registerModifier('trace', (_event, _element, action) => {
+     *   action.meta ??= {};
+     *   action.meta['time'] = Date.now();
+     *   return true;
+     * });
+     * ```
+     */
+    registerModifier(name: string, handler: ModifierHandler): void;
+    /**
+     * Registers a custom payload resolver to map DOM state to action payload.
+     *
+     * @param name     - Resolver token (by convention starting with `$`).
+     * @param resolver - Function yielding payload from the event and element.
+     *
+     * @example
+     * ```ts
+     * actionService.registerPayloadResolver('$data-id', (_event, element) => {
+     *   return element.dataset.id;
+     * });
+     * ```
+     */
+    registerPayloadResolver(name: string, resolver: PayloadResolver): void;
+    /**
+     * Registers global event delegation listeners on `document.body`.
+     *
+     * @param eventTypes - List of event types to delegate. Defaults to ActionService.DEFAULT_DELEGATED_EVENTS.
+     *
+     * @example
+     * ```ts
+     * actionService.setupDelegation();
+     * ```
+     */
+    setupDelegation(eventTypes?: readonly string[]): void;
+    /**
+     * Unregisters all global event delegation listeners.
+     *
+     * @example
+     * ```ts
+     * actionService.teardownDelegation();
+     * ```
+     */
+    teardownDelegation(): void;
+    /**
+     * Parses attribute values into action descriptor, utilizing the internal cache.
+     * @protected
+     */
+    protected parseDescriptor_(attributeValue: string): ActionDescriptor | null;
+    /**
+     * Global event delegation handler.
+     * @protected
+     */
+    protected handleDelegatedEvent_(event: Event): void;
+    /**
+     * Registers default modifiers and resolvers.
+     * @private
+     */
+    private registerDefaultModifiersAndResolvers__;
+}
+/**
+ * Singleton instance of the ActionService.
+ * Ready for immediate use.
+ *
+ * @example
+ * ```ts
+ * import {actionService} from '@alwatr/action';
+ *
+ * actionService.setupDelegation();
+ * ```
+ */
+export declare const actionService: ActionService;
+export {};
+//# sourceMappingURL=action-service.d.ts.map

package/dist/action-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-service.d.ts","sourceRoot":"","sources":["../src/action-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAW,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAC,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAC,MAAM,WAAW,CAAC;AAErG;;;GAGG;AACH,UAAU,gBAAgB;IACxB,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAQD;;;;;;;;;;GAUG;AACH,qBAAa,aAAa;IACxB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,wBAAwB,EAAE,SAAS,MAAM,EAAE,CAA0C;IAErG,SAAS,CAAC,QAAQ,CAAC,OAAO,wCAAkC;IAE5D;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,gBAAgB,wEAAyE;IAE5G;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,iBAAiB,+BAAsC;IAE1E;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,gBAAgB,+BAAsC;IAEzE;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,gBAAgB,uCAA8C;IAEjF;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,oBAAoB,cAAqB;IAE5D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAyC;;IAOrF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,YAAY,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,GAAG,eAAe;IAuBjH;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,CAAC,SAAS,MAAM,YAAY,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IAKtE;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI;IAS9D;;;;;;;;;;;;OAYG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI;IAStE;;;;;;;;;OASG;IACH,eAAe,CAAC,UAAU,GAAE,SAAS,MAAM,EAA2C,GAAG,IAAI;IAc7F;;;;;;;OAOG;IACH,kBAAkB,IAAI,IAAI;IAY1B;;;OAGG;IACH,SAAS,CAAC,gBAAgB,CAAC,cAAc,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAuB3E;;;OAGG;IACH,SAAS,CAAC,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAkFnD;;;OAGG;IACH,OAAO,CAAC,sCAAsC;CA6B/C;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,eAAsB,CAAC"}