effectable 0.1.0

package/build/component/h.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * VirtualServiceNode factory for declarative component tree composition.
+ * Declarative element factory for a backend runtime graph (virtual service nodes).
+ *
+ * h() describes topology with no side effects — no network calls,
+ * subscriptions, or handler registration inside an h() call.
+ *
+ * @module Effectable/component/h
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.h = h;
+/**
+ * Singleton: immutable empty children array used by default.
+ *
+ * Used in {@link h} when no children are passed, to avoid allocating `[]` on every call.
+ * `Object.freeze` preserves the immutability invariant of the {@link VirtualServiceNode} structure.
+ */
+const EMPTY_CHILDREN = Object.freeze([]);
+function h(type, props, refOrChildrenOrKey, childrenOrKey, maybeKey) {
+    const resolvedProps = (props === undefined ? {} : props);
+    // Fast-path: most common case — h(type) / h(type, props) without ref/children/key.
+    // Return a shape-stable object without intermediate checks (41x speedup).
+    if (refOrChildrenOrKey === undefined) {
+        return {
+            type: type,
+            props: resolvedProps,
+            ref: undefined,
+            children: EMPTY_CHILDREN,
+        };
+    }
+    let resolvedRef;
+    let resolvedChildren;
+    let resolvedKey;
+    if (typeof refOrChildrenOrKey === 'string') {
+        resolvedRef = undefined;
+        resolvedChildren = EMPTY_CHILDREN;
+        resolvedKey = refOrChildrenOrKey;
+    }
+    else if (Array.isArray(refOrChildrenOrKey)) {
+        resolvedRef = undefined;
+        resolvedChildren = refOrChildrenOrKey;
+        resolvedKey = typeof childrenOrKey === 'string' ? childrenOrKey : undefined;
+    }
+    else {
+        resolvedRef = refOrChildrenOrKey;
+        if (typeof childrenOrKey === 'string') {
+            resolvedChildren = EMPTY_CHILDREN;
+            resolvedKey = childrenOrKey;
+        }
+        else {
+            resolvedChildren = childrenOrKey ?? EMPTY_CHILDREN;
+            resolvedKey = maybeKey;
+        }
+    }
+    if (resolvedKey === undefined) {
+        return {
+            type: type,
+            props: resolvedProps,
+            ref: resolvedRef,
+            children: resolvedChildren,
+        };
+    }
+    return {
+        type: type,
+        props: resolvedProps,
+        ref: resolvedRef,
+        children: resolvedChildren,
+        key: resolvedKey,
+    };
+}
+//# sourceMappingURL=h.js.map

package/build/component/h.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"h.js","sourceRoot":"","sources":["../../src/component/h.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAyDH,cA2DC;AAhHD;;;;;GAKG;AACH,MAAM,cAAc,GAAkC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAkC,CAAC;AA+CzG,SAAgB,CAAC,CACf,IAA6B,EAC7B,KAAS,EACT,kBAAuE,EACvE,aAA6C,EAC7C,QAAiB;IAEjB,MAAM,aAAa,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAM,CAAC;IAE9D,mFAAmF;IACnF,0EAA0E;IAC1E,IAAI,kBAAkB,KAAK,SAAS,EAAE,CAAC;QACrC,OAAO;YACL,IAAI,EAAE,IAAqC;YAC3C,KAAK,EAAE,aAAa;YACpB,GAAG,EAAE,SAAS;YACd,QAAQ,EAAE,cAAsC;SACjD,CAAC;IACJ,CAAC;IAED,IAAI,WAA2C,CAAC;IAChD,IAAI,gBAAsC,CAAC;IAC3C,IAAI,WAA+B,CAAC;IAEpC,IAAI,OAAO,kBAAkB,KAAK,QAAQ,EAAE,CAAC;QAC3C,WAAW,GAAG,SAAS,CAAC;QACxB,gBAAgB,GAAG,cAAsC,CAAC;QAC1D,WAAW,GAAG,kBAAkB,CAAC;IACnC,CAAC;SAAM,IAAI,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC;QAC7C,WAAW,GAAG,SAAS,CAAC;QACxB,gBAAgB,GAAG,kBAAkB,CAAC;QACtC,WAAW,GAAG,OAAO,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9E,CAAC;SAAM,CAAC;QACN,WAAW,GAAG,kBAAkB,CAAC;QACjC,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;YACtC,gBAAgB,GAAG,cAAsC,CAAC;YAC1D,WAAW,GAAG,aAAa,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,gBAAgB,GAAG,aAAa,IAAK,cAAuC,CAAC;YAC7E,WAAW,GAAG,QAAQ,CAAC;QACzB,CAAC;IACH,CAAC;IAED,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO;YACL,IAAI,EAAE,IAAqC;YAC3C,KAAK,EAAE,aAAa;YACpB,GAAG,EAAE,WAAW;YAChB,QAAQ,EAAE,gBAAgB;SAC3B,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,IAAqC;QAC3C,KAAK,EAAE,aAAa;QACpB,GAAG,EAAE,WAAW;QAChB,QAAQ,EAAE,gBAAgB;QAC1B,GAAG,EAAE,WAAW;KACjB,CAAC;AACJ,CAAC"}

package/build/component/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Re-exports types, the base Component class, and declarative composition utilities for Effectable/component.
+ *
+ * @module Effectable/component
+ */
+export type { Lifecycle, Disposable, RuntimePropsReceiver, RefObject, VirtualServiceNode, NodeLifecycleStatus, FiberEffectTag, FiberInspectNode, Fiber, ComponentConstructor, } from './types';
+export { RUNTIME_PROPS_RECEIVER, FIBER_EFFECT_TAG } from './types';
+export { Component } from './Component';
+export type { SetStateUpdate } from './Component';
+export { h } from './h';
+export { LifecycleEngine } from './lifecycle';
+export type { LifecycleTransitionResult } from './lifecycle';
+export { UseRef, UseImperativeHandle, getRefFields, getImperativeHandleMethods } from './refs';
+export type { RefFieldMeta, ImperativeHandleMeta } from './refs';
+export { REF_FIELDS_META_KEY, IMPERATIVE_HANDLE_META_KEY } from './refs';
+export { createContext, extendScope, readFromScope, ContextProvider, UseContext, getContextFields, injectContextFields, EMPTY_CONTEXT_SCOPE, CONTEXT_FIELDS_META_KEY, } from './context';
+export type { ContextToken, ContextScope, ContextProviderProps, ContextFieldMeta, } from './context';
+export { GraphRuntime, makeFiberEffectTag } from './GraphRuntime';
+//# sourceMappingURL=index.d.ts.map

package/build/component/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/component/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACV,SAAS,EACT,UAAU,EACV,oBAAoB,EACpB,SAAS,EACT,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,KAAK,EACL,oBAAoB,GACrB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,YAAY,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,YAAY,EAAE,0BAA0B,EAAE,MAAM,QAAQ,CAAC;AAC/F,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,QAAQ,CAAC;AACzE,OAAO,EACL,aAAa,EACb,WAAW,EACX,aAAa,EACb,eAAe,EACf,UAAU,EACV,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC"}

package/build/component/index.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Re-exports types, the base Component class, and declarative composition utilities for Effectable/component.
+ *
+ * @module Effectable/component
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFiberEffectTag = exports.GraphRuntime = exports.CONTEXT_FIELDS_META_KEY = exports.EMPTY_CONTEXT_SCOPE = exports.injectContextFields = exports.getContextFields = exports.UseContext = exports.ContextProvider = exports.readFromScope = exports.extendScope = exports.createContext = exports.IMPERATIVE_HANDLE_META_KEY = exports.REF_FIELDS_META_KEY = exports.getImperativeHandleMethods = exports.getRefFields = exports.UseImperativeHandle = exports.UseRef = exports.LifecycleEngine = exports.h = exports.Component = exports.FIBER_EFFECT_TAG = exports.RUNTIME_PROPS_RECEIVER = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "RUNTIME_PROPS_RECEIVER", { enumerable: true, get: function () { return types_1.RUNTIME_PROPS_RECEIVER; } });
+Object.defineProperty(exports, "FIBER_EFFECT_TAG", { enumerable: true, get: function () { return types_1.FIBER_EFFECT_TAG; } });
+var Component_1 = require("./Component");
+Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return Component_1.Component; } });
+var h_1 = require("./h");
+Object.defineProperty(exports, "h", { enumerable: true, get: function () { return h_1.h; } });
+var lifecycle_1 = require("./lifecycle");
+Object.defineProperty(exports, "LifecycleEngine", { enumerable: true, get: function () { return lifecycle_1.LifecycleEngine; } });
+var refs_1 = require("./refs");
+Object.defineProperty(exports, "UseRef", { enumerable: true, get: function () { return refs_1.UseRef; } });
+Object.defineProperty(exports, "UseImperativeHandle", { enumerable: true, get: function () { return refs_1.UseImperativeHandle; } });
+Object.defineProperty(exports, "getRefFields", { enumerable: true, get: function () { return refs_1.getRefFields; } });
+Object.defineProperty(exports, "getImperativeHandleMethods", { enumerable: true, get: function () { return refs_1.getImperativeHandleMethods; } });
+var refs_2 = require("./refs");
+Object.defineProperty(exports, "REF_FIELDS_META_KEY", { enumerable: true, get: function () { return refs_2.REF_FIELDS_META_KEY; } });
+Object.defineProperty(exports, "IMPERATIVE_HANDLE_META_KEY", { enumerable: true, get: function () { return refs_2.IMPERATIVE_HANDLE_META_KEY; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "createContext", { enumerable: true, get: function () { return context_1.createContext; } });
+Object.defineProperty(exports, "extendScope", { enumerable: true, get: function () { return context_1.extendScope; } });
+Object.defineProperty(exports, "readFromScope", { enumerable: true, get: function () { return context_1.readFromScope; } });
+Object.defineProperty(exports, "ContextProvider", { enumerable: true, get: function () { return context_1.ContextProvider; } });
+Object.defineProperty(exports, "UseContext", { enumerable: true, get: function () { return context_1.UseContext; } });
+Object.defineProperty(exports, "getContextFields", { enumerable: true, get: function () { return context_1.getContextFields; } });
+Object.defineProperty(exports, "injectContextFields", { enumerable: true, get: function () { return context_1.injectContextFields; } });
+Object.defineProperty(exports, "EMPTY_CONTEXT_SCOPE", { enumerable: true, get: function () { return context_1.EMPTY_CONTEXT_SCOPE; } });
+Object.defineProperty(exports, "CONTEXT_FIELDS_META_KEY", { enumerable: true, get: function () { return context_1.CONTEXT_FIELDS_META_KEY; } });
+var GraphRuntime_1 = require("./GraphRuntime");
+Object.defineProperty(exports, "GraphRuntime", { enumerable: true, get: function () { return GraphRuntime_1.GraphRuntime; } });
+Object.defineProperty(exports, "makeFiberEffectTag", { enumerable: true, get: function () { return GraphRuntime_1.makeFiberEffectTag; } });
+//# sourceMappingURL=index.js.map

package/build/component/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/component/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAcH,iCAAmE;AAA1D,+GAAA,sBAAsB,OAAA;AAAE,yGAAA,gBAAgB,OAAA;AACjD,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAElB,yBAAwB;AAAf,sFAAA,CAAC,OAAA;AACV,yCAA8C;AAArC,4GAAA,eAAe,OAAA;AAExB,+BAA+F;AAAtF,8FAAA,MAAM,OAAA;AAAE,2GAAA,mBAAmB,OAAA;AAAE,oGAAA,YAAY,OAAA;AAAE,kHAAA,0BAA0B,OAAA;AAE9E,+BAAyE;AAAhE,2GAAA,mBAAmB,OAAA;AAAE,kHAAA,0BAA0B,OAAA;AACxD,qCAUmB;AATjB,wGAAA,aAAa,OAAA;AACb,sGAAA,WAAW,OAAA;AACX,wGAAA,aAAa,OAAA;AACb,0GAAA,eAAe,OAAA;AACf,qGAAA,UAAU,OAAA;AACV,2GAAA,gBAAgB,OAAA;AAChB,8GAAA,mBAAmB,OAAA;AACnB,8GAAA,mBAAmB,OAAA;AACnB,kHAAA,uBAAuB,OAAA;AAQzB,+CAAkE;AAAzD,4GAAA,YAAY,OAAA;AAAE,kHAAA,kBAAkB,OAAA"}

package/build/component/lifecycle.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Node lifecycle engine (`LifecycleEngine`) and transition result type.
+ *
+ * The state machine defines stage order: `registered` → `resolved` → `created` →
+ * `mounted` → `ready` → `unmounting` → `unmounted` → `destroyed`.
+ * Any stage may transition to `failed`; there is no reverse transition from `failed`
+ * (except forced `destroy` via teardown scenarios).
+ *
+ * Public component hooks are called in the expected order:
+ * - startup: `onMount`
+ * - in stage `ready`: `onUpdate` (as decided by GraphRuntime)
+ * - shutdown / cleanup: `onUnmount`
+ *
+ * @module Effectable/component/lifecycle
+ */
+import type { Component } from './Component';
+import type { NodeLifecycleStatus } from './types';
+/**
+ * Result of an asynchronous lifecycle transition attempt (startup / shutdown).
+ *
+ * Errors from hooks are not rethrown: on failure the branch
+ * `{ ok: false, error }` is returned; success is `{ ok: true }`.
+ */
+export type LifecycleTransitionResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: unknown;
+};
+/**
+ * Target stage name for {@link LifecycleEngine.canTransitionTo}: only “forward” along the graph,
+ * without returning to already passed stages (except special rules for `failed`).
+ */
+type ForwardStage = 'resolved' | 'created' | 'mounted' | 'ready' | 'unmounting' | 'unmounted' | 'destroyed' | 'failed';
+/**
+ * Lifecycle state machine for one node in GraphRuntime: one instance
+ * per node (fiber).
+ *
+ * Invariants:
+ * - stages mostly advance monotonically; update passes are allowed in `ready`;
+ * - after `failed`, further transitions are limited (see {@link canTransitionTo});
+ * - {@link Component.onUnmount} is called at most once per instance.
+ *
+ * @example
+ * const engine = new LifecycleEngine();
+ * engine.initHookFlags(component);
+ * await engine.runStartup(component);
+ */
+export declare class LifecycleEngine {
+    /**
+     * Current stage as a number (see {@link STAGE}): comparisons without string lookups.
+     */
+    private currentStage;
+    private unmountCalled;
+    /**
+     * Bit flags for which hooks the component has.
+     * 0 — hooks not initialized or absent (fast-exit in runStartup/runShutdown).
+     * Set via initHookFlags() after instance creation.
+     */
+    private hookFlags;
+    /**
+     * Whether hookFlags were initialized via initHookFlags().
+     * Without this, the fast-exit on hookFlags === 0 would apply before initialization.
+     */
+    private hookFlagsInitialized;
+    /**
+     * Returns the string node status for the external API (GraphRuntime, debugging, UI).
+     *
+     * @returns {NodeLifecycleStatus} current stage as `NodeLifecycleStatus`
+     */
+    getStatus(): NodeLifecycleStatus;
+    /**
+     * Computes and stores a bit mask of hook methods present on the instance.
+     * Must be called exactly once after instance creation (e.g. from materialize).
+     * Lets {@link runStartup} and {@link runShutdown} skip per-hook checks
+     * when none are declared.
+     *
+     * @param {Component<unknown, unknown>} instance - component instance with optional hooks
+     * @returns {void}
+     */
+    initHookFlags(instance: Component<unknown, unknown>): void;
+    /**
+     * Startup phase: if present — call `onMount`, advance stages to `ready`.
+     * On exception: stage already `Mounted` → {@link runFailedCleanup}(`wasMounted=true`)
+     * (attempt `onUnmount` + teardown), result `{ ok: false, error }`.
+     *
+     * Returns a synchronous {@link LifecycleTransitionResult} if `onMount` returned
+     * a non-thenable value (sync fast-path); otherwise a Promise.
+     * `await` works correctly with either union branch.
+     *
+     * @param {Component<unknown, unknown>} instance - component instance
+     * @returns {LifecycleTransitionResult | Promise<LifecycleTransitionResult>}
+     */
+    runStartup(instance: Component<unknown, unknown>): LifecycleTransitionResult | Promise<LifecycleTransitionResult>;
+    /**
+     * Async continuation of {@link runStartup} after `onMount` returned a Promise.
+     *
+     * @param {Component<unknown, unknown>} instance - component instance
+     * @param {PromiseLike<unknown>} pending - Promise from onMount
+     * @returns {Promise<LifecycleTransitionResult>}
+     */
+    private continueStartupAsync;
+    /**
+     * Shutdown phase: if needed `onUnmount`, stages `unmounting` → `unmounted` → `destroyed`.
+     * If the node is already `destroyed`, noop. An error in `onUnmount` is returned as `{ ok: false, error }`.
+     *
+     * Returns a synchronous {@link LifecycleTransitionResult} if `onUnmount` returned non-thenable
+     * (sync fast-path); otherwise a Promise. `await` works correctly
+     * with either union branch.
+     *
+     * @param {Component<unknown, unknown>} instance - component instance
+     * @returns {LifecycleTransitionResult | Promise<LifecycleTransitionResult>}
+     */
+    runShutdown(instance: Component<unknown, unknown>): LifecycleTransitionResult | Promise<LifecycleTransitionResult>;
+    /**
+     * Async continuation of {@link runShutdown} after `onUnmount` returned a Promise.
+     *
+     * @param {PromiseLike<unknown>} pendingUnmount - Promise from onUnmount
+     * @returns {Promise<LifecycleTransitionResult>}
+     */
+    private continueShutdownAsync;
+    /**
+     * Forced cleanup after failure: stage `failed`, if `wasMounted` — attempt
+     * `onUnmount` (errors swallowed), then final teardown.
+     * Used on `onMount` fail (stage already `Mounted`) and by GraphRuntime on errors
+     * outside startup (e.g. during update).
+     *
+     * Returns `void` synchronously if `onUnmount` is absent or returned non-thenable;
+     * otherwise a Promise.
+     *
+     * @param {Component<unknown, unknown>} instance - component instance
+     * @param {boolean} wasMounted - `true` if the node had already mounted before the error
+     * @returns {void | Promise<void>}
+     */
+    runFailedCleanup(instance: Component<unknown, unknown>, wasMounted: boolean): void | Promise<void>;
+    /**
+     * Async continuation of {@link runFailedCleanup} after async unmount.
+     *
+     * @param {PromiseLike<unknown>} pendingUnmount - Promise from onUnmount
+     * @returns {Promise<void>}
+     */
+    private continueFailedCleanupAsync;
+    /**
+     * Idempotent teardown: marks the node as `destroyed`. No `onDestroy` call
+     * (legacy hook removed); side-effect cleanup happens in `onUnmount`.
+     *
+     * @returns {void | Promise<void>} always `void` (signature kept for compatibility)
+     */
+    private runForcedDestroy;
+    /**
+     * Whether the node can accept an update pass (`onUpdate`): only stage `ready`.
+     *
+     * @returns {boolean} `true` if an update-pass may be called
+     */
+    canUpdate(): boolean;
+    /**
+     * Whether the node is in a terminal stage: `destroyed` or `failed` (further work with the node is not expected).
+     *
+     * @returns {boolean} `true` for `destroyed` and `failed`
+     */
+    isTerminated(): boolean;
+    /**
+     * Moves the node to `failed` without calling hooks (external error, marking in GraphRuntime).
+     * If the node is already terminal, state is unchanged.
+     *
+     * @returns {void}
+     */
+    markFailed(): void;
+    /**
+     * Whether a “forward” transition to `target` is allowed relative to the current numeric stage.
+     * From `failed` only a transition to `destroyed` is allowed (aligned with forced teardown).
+     *
+     * @param {ForwardStage} target - target stage under test by string name
+     * @returns {boolean} `true` if the target stage is strictly “later” than current (or special case `failed`→`destroyed`)
+     */
+    canTransitionTo(target: ForwardStage): boolean;
+}
+export {};
+//# sourceMappingURL=lifecycle.d.ts.map

package/build/component/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/component/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GACjC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAElC;;;GAGG;AACH,KAAK,YAAY,GACb,UAAU,GACV,SAAS,GACT,SAAS,GACT,OAAO,GACP,YAAY,GACZ,WAAW,GACX,WAAW,GACX,QAAQ,CAAC;AAoFb;;;;;;;;;;;;;GAaG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACH,OAAO,CAAC,YAAY,CAAoC;IACxD,OAAO,CAAC,aAAa,CAAS;IAE9B;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAAK;IAEtB;;;OAGG;IACH,OAAO,CAAC,oBAAoB,CAAS;IAErC;;;;OAIG;IACI,SAAS,IAAK,mBAAmB;IAIxC;;;;;;;;OAQG;IACI,aAAa,CAAE,QAAQ,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IASlE;;;;;;;;;;;OAWG;IACI,UAAU,CACf,QAAQ,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GACpC,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAiCjE;;;;;;OAMG;YACW,oBAAoB;IAiBlC;;;;;;;;;;OAUG;IACI,WAAW,CAChB,QAAQ,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GACpC,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAmCjE;;;;;OAKG;YACW,qBAAqB;IAmBnC;;;;;;;;;;;;OAYG;IACI,gBAAgB,CACrB,QAAQ,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,UAAU,EAAE,OAAO,GAClB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBvB;;;;;OAKG;YACW,0BAA0B;IAexC;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;;OAIG;IACI,SAAS,IAAK,OAAO;IAI5B;;;;OAIG;IACI,YAAY,IAAK,OAAO;IAM/B;;;;;OAKG;IACI,UAAU,IAAK,IAAI;IAM1B;;;;;;OAMG;IACI,eAAe,CAAE,MAAM,EAAE,YAAY,GAAG,OAAO;CAQvD"}