@typed/ui 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/Carousel.js

@@ -0,0 +1,387 @@
+/**
+ * Carousel state keeps the active slide and rotation pause policy outside the renderer. Root
+ * pauses rotation on focus and pointer entry; slides retain DOM identity while hidden; controls
+ * use native button clicks.
+ *
+ * @remarks
+ * The module keeps policy, state transitions, and DOM rendering separable so applications can use
+ * the state and pure operations without mounting UI, or supply custom hosts without replacing native
+ * events and browser-owned focus.
+ *
+ * @since 1.0.0
+ * @category modules
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { RefSubject } from "@typed/fx";
+import { html } from "@typed/template";
+import * as Collection from "./Collection.js";
+import * as Composite from "./Composite.js";
+import * as Dom from "./Dom.js";
+/**
+ * Effect Schema used by makeState to encode, decode, and hydrate Carousel state.
+ *
+ * @remarks
+ * ## Why
+ *
+ * A public schema makes hydration and serialized state use the same runtime validation as direct
+ * construction.
+ *
+ * ## Ownership and lifetime
+ *
+ * This declaration is data or schema metadata and acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import * as Schema from "effect/Schema";
+ * import * as Carousel from "@typed/ui/Carousel";
+ *
+ * const decodeState = Schema.decodeUnknownEffect(Carousel.StateSchema);
+ * ```
+ * @since 1.0.0
+ * @category schemas
+ */
+export const StateSchema = Schema.Struct({ activeId: Schema.String, paused: Schema.Boolean });
+/**
+ * Creates hydrated Carousel state. activeId is required and paused defaults to true.
+ *
+ * @remarks
+ * ## Why
+ *
+ * State and collection ownership can be composed and tested independently from any renderer.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Effect creates the RefSubject when run. That state is renderer-independent;
+ * collection registrations belong to the separate Scope that runs register or ref, not to state
+ * creation.
+ *
+ * @example
+ * ```ts
+ * import * as Effect from "effect/Effect";
+ * import * as Carousel from "@typed/ui/Carousel";
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function* () {
+ *     const state = yield* Carousel.makeState({ activeId: "slide-1" });
+ *     const collection = yield* Carousel.makeCollection();
+ *     return { state: yield* state, collection: yield* collection };
+ *   }),
+ * );
+ * ```
+ * @since 1.0.0
+ * @category constructors
+ */
+export function makeState(initial) {
+    return RefSubject.hydrate(StateSchema, {
+        activeId: initial.activeId,
+        paused: initial.paused ?? true,
+    });
+}
+/**
+ * Creates a scoped Collection for Carousel items.
+ *
+ * @remarks
+ * ## Why
+ *
+ * State and collection ownership can be composed and tested independently from any renderer.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Effect allocates the RefSubject in the caller's Scope. Each later registration is
+ * owned by the Scope that runs register, independently of this construction Effect.
+ *
+ * @example
+ * ```ts
+ * import * as Effect from "effect/Effect";
+ * import * as Carousel from "@typed/ui/Carousel";
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function* () {
+ *     const collection = yield* Carousel.makeCollection();
+ *     return yield* collection;
+ *   }),
+ * );
+ * ```
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeCollection = Collection.makeState;
+/**
+ * Sets activeId without changing paused state.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The operation exposes Carousel's transition directly so callers can compose it in Effect
+ * programs and native event handlers.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Effect performs the update or DOM side effect only when run, preserves the declared
+ * error and service channels, and retains no resources after completion.
+ *
+ * ## Example
+ *
+ * Import with `import { select } from "@typed/ui/Carousel";` Extend the [Carousel.makeState
+ * runnable setup](/reference/%40typed%2Fui%2FCarousel%23makeState). Inside the linked Effect
+ * program invoke `yield* select(state, "slide-2")`, then read state to observe `activeId` become
+ * `"slide-2"` without changing `paused`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function select(state, activeId) {
+    return RefSubject.update(state, (current) => ({ ...current, activeId }));
+}
+/**
+ * Selects the previous or next enabled registered slide; movement wraps and leaves state unchanged
+ * for an empty collection.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The operation exposes Carousel's transition directly so callers can compose it in Effect
+ * programs and native event handlers.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Effect performs the update or DOM side effect only when run, preserves the declared
+ * error and service channels, and retains no resources after completion.
+ *
+ * ## Example
+ *
+ * Import with `import { move } from "@typed/ui/Carousel";` Extend the [Carousel.makeState runnable
+ * setup](/reference/%40typed%2Fui%2FCarousel%23makeState). Inside the linked Effect program invoke
+ * `yield* move(state, collection, "next")`, then read the state snapshot to observe the transition
+ * described above.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function move(state, collection, direction) {
+    return Effect.gen(function* () {
+        const next = Composite.moveActiveId(yield* collection, { activeId: (yield* state).activeId, loop: true }, direction);
+        return next === null ? yield* state : yield* select(state, next);
+    });
+}
+/**
+ * Flips paused and preserves activeId.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The operation exposes Carousel's transition directly so callers can compose it in Effect
+ * programs and native event handlers.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Effect performs the update or DOM side effect only when run, preserves the declared
+ * error and service channels, and retains no resources after completion.
+ *
+ * ## Example
+ *
+ * Import with `import { toggleRotation } from "@typed/ui/Carousel";` Extend the [Carousel.makeState
+ * runnable setup](/reference/%40typed%2Fui%2FCarousel%23makeState). Inside the linked Effect
+ * program invoke `yield* toggleRotation(state)`, then read state to observe `paused` invert without
+ * changing `activeId`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function toggleRotation(state) {
+    return RefSubject.update(state, (current) => ({ ...current, paused: !current.paused }));
+}
+function rootInternalProps(options) {
+    const pause = RefSubject.update(options.state, (current) => current.paused ? current : { ...current, paused: true });
+    let resumeOnPointerLeave = false;
+    const pauseForFocus = Effect.andThen(Effect.sync(() => {
+        resumeOnPointerLeave = false;
+    }), pause);
+    const pauseForPointer = Effect.flatMap(options.state, (current) => {
+        resumeOnPointerLeave = !current.paused;
+        return pause;
+    });
+    const resumeAfterPointer = Effect.suspend(() => {
+        if (!resumeOnPointerLeave)
+            return Effect.void;
+        resumeOnPointerLeave = false;
+        return RefSubject.update(options.state, (current) => current.paused ? { ...current, paused: false } : current);
+    });
+    return ({ property }) => ({
+        role: "region",
+        "aria-roledescription": "carousel",
+        "aria-label": property("label", undefined),
+        onfocusin: pauseForFocus,
+        onmouseenter: pauseForPointer,
+        onmouseleave: resumeAfterPointer,
+        ref: options.state,
+    });
+}
+/**
+ * Renders the carousel region and pauses automatic rotation on focus or pointer entry without
+ * replacing its child nodes.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The component applies the family behavior while leaving callers free to supply a custom host
+ * through the shared DOM boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Fx installs DOM refs, native listeners, state subscriptions, and optional
+ * collection registrations only when rendered. The rendering Scope removes those resources;
+ * unrelated nodes and attributes remain caller-owned.
+ *
+ * ## Example
+ *
+ * Import with `import { Root } from "@typed/ui/Carousel";` Extend the [Carousel.makeState runnable
+ * setup](/reference/%40typed%2Fui%2FCarousel%23makeState). Replace the linked program's final
+ * snapshot read with `Root({ state, content: "Slides", label: "Featured" })`; render that Fx before
+ * the same Scope closes.
+ * @since 1.0.0
+ * @category components
+ */
+export function Root(options, host) {
+    return Dom.renderHost()(options, host, rootInternalProps(options), options.content, (props, content) => {
+        return html `<div ...${props}>${content}</div>`;
+    });
+}
+function slideInternalProps(options) {
+    const register = options.collection === undefined
+        ? undefined
+        : Collection.ref(options.collection, {
+            id: options.id,
+            value: options.id,
+            textValue: options.id,
+        });
+    return ({ property }) => ({
+        id: options.id,
+        role: "group",
+        "aria-roledescription": "slide",
+        "aria-label": property("label", undefined),
+        "?hidden": RefSubject.map(options.state, (state) => state.activeId !== options.id),
+        ref: register,
+    });
+}
+/**
+ * Renders one labelled slide, registers it when a collection is supplied, and toggles hidden from
+ * activeId.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The component applies the family behavior while leaving callers free to supply a custom host
+ * through the shared DOM boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Fx installs DOM refs, native listeners, state subscriptions, and optional
+ * collection registrations only when rendered. The rendering Scope removes those resources;
+ * unrelated nodes and attributes remain caller-owned.
+ *
+ * ## Example
+ *
+ * Import with `import { Slide } from "@typed/ui/Carousel";` Extend the [Carousel.makeState runnable
+ * setup](/reference/%40typed%2Fui%2FCarousel%23makeState). Replace the linked program's final
+ * snapshot read with `Slide({ state, id: "slide-1", label: "1 of 3", content: "First slide" })`;
+ * render that Fx before the same Scope closes.
+ * @since 1.0.0
+ * @category components
+ */
+export function Slide(options, host) {
+    return Dom.renderHost()(options, host, slideInternalProps(options), options.content, (props, content) => {
+        return html `<div ...${props}>${content}</div>`;
+    });
+}
+function controlInternalProps(options, action) {
+    return () => ({ type: "button", onclick: action });
+}
+function control(options, host, action) {
+    const internal = controlInternalProps(options, action);
+    return Dom.renderHost()(options, host, internal, options.content, (props, content) => html `<button ...${props}>${content}</button>`);
+}
+/**
+ * Renders a button whose native click selects the previous registered slide with wrapping enabled.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The component applies the family behavior while leaving callers free to supply a custom host
+ * through the shared DOM boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Fx installs DOM refs, native listeners, state subscriptions, and optional
+ * collection registrations only when rendered. The rendering Scope removes those resources;
+ * unrelated nodes and attributes remain caller-owned.
+ *
+ * ## Example
+ *
+ * Import with `import { Previous } from "@typed/ui/Carousel";` Extend the [Carousel.makeState
+ * runnable setup](/reference/%40typed%2Fui%2FCarousel%23makeState). Replace the linked program's
+ * final snapshot read with `Previous({ state, content: "Previous" })`; render that Fx before the
+ * same Scope closes.
+ * @since 1.0.0
+ * @category components
+ */
+export function Previous(options, host) {
+    return control(options, host, options.collection === undefined
+        ? Effect.void
+        : move(options.state, options.collection, "previous"));
+}
+/**
+ * Renders a button whose native click selects the next registered slide with wrapping enabled.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The component applies the family behavior while leaving callers free to supply a custom host
+ * through the shared DOM boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Fx installs DOM refs, native listeners, state subscriptions, and optional
+ * collection registrations only when rendered. The rendering Scope removes those resources;
+ * unrelated nodes and attributes remain caller-owned.
+ *
+ * ## Example
+ *
+ * Import with `import { Next } from "@typed/ui/Carousel";` Extend the [Carousel.makeState runnable
+ * setup](/reference/%40typed%2Fui%2FCarousel%23makeState). Replace the linked program's final
+ * snapshot read with `Next({ state, content: "Next" })`; render that Fx before the same Scope
+ * closes.
+ * @since 1.0.0
+ * @category components
+ */
+export function Next(options, host) {
+    return control(options, host, options.collection === undefined
+        ? Effect.void
+        : move(options.state, options.collection, "next"));
+}
+/**
+ * Renders a button whose native click toggles the explicit paused state.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The component applies the family behavior while leaving callers free to supply a custom host
+ * through the shared DOM boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Fx installs DOM refs, native listeners, state subscriptions, and optional
+ * collection registrations only when rendered. The rendering Scope removes those resources;
+ * unrelated nodes and attributes remain caller-owned.
+ *
+ * ## Example
+ *
+ * Import with `import { RotationControl } from "@typed/ui/Carousel";` Extend the
+ * [Carousel.makeState runnable setup](/reference/%40typed%2Fui%2FCarousel%23makeState). Replace the
+ * linked program's final snapshot read with `RotationControl({ state, content: "Pause rotation"
+ * })`; render that Fx before the same Scope closes.
+ * @since 1.0.0
+ * @category components
+ */
+export function RotationControl(options, host) {
+    return control(options, host, toggleRotation(options.state));
+}

package/dist/Checkbox.d.ts

@@ -0,0 +1,203 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { RefSubject } from "@typed/fx";
+import { EventHandler } from "@typed/template";
+import * as Dom from "./Dom.js";
+import type { HostResult } from "./Dom/Types.js";
+/** Three-state value accepted by a checkbox.
+ * @remarks
+ * ## Why
+ * `"mixed"` models the platform's indeterminate presentation without
+ * conflating it with either submitted boolean state.
+ * ## Ownership and lifetime
+ * This pure type acquires no resources.
+ * @since 1.0.0
+ * @category models
+ */
+export type Checked = boolean | "mixed";
+/** Current renderer-independent checkbox state.
+ * @remarks
+ * ## Why
+ * State can be updated and tested through RefSubject before any input mounts.
+ * ## Ownership and lifetime
+ * The value is plain data; the hydrated RefSubject returned by `makeState`
+ * owns observation for its Effect Scope.
+ * @since 1.0.0
+ * @category state
+ */
+export interface State {
+    /** Current checked or mixed value.
+     * @remarks
+     * ## Why
+     * One field drives `checked`, `indeterminate`, and `aria-checked` together.
+     * ## Ownership and lifetime
+     * Plain state retains no resources.
+     * @since 1.0.0
+     * @category state
+     */
+    readonly checked: Checked;
+}
+/** Initial checkbox state accepted by `makeState`.
+ * @remarks
+ * ## Why
+ * The optional value gives uncontrolled creation a deterministic false default.
+ * ## Ownership and lifetime
+ * This configuration is inert and retains no resources.
+ * @since 1.0.0
+ * @category state
+ */
+export interface InitialState {
+    /** Initial checked value; defaults to `false`.
+     * @remarks
+     * ## Why
+     * Explicit mixed state can survive SSR hydration.
+     * ## Ownership and lifetime
+     * The value is copied into hydrated state and retains no resource.
+     * @since 1.0.0
+     * @category state
+     */
+    readonly checked?: Checked;
+}
+/** Schema used to encode and hydrate checkbox state.
+ * @remarks
+ * ## Why
+ * A shared schema keeps server and client state shape identical.
+ * ## Ownership and lifetime
+ * The schema is immutable and acquires no resources.
+ * @since 1.0.0
+ * @category schemas
+ */
+export declare const StateSchema: Schema.Struct<{
+    readonly checked: Schema.Literals<readonly [true, false, "mixed"]>;
+}>;
+/** Creates hydrated, renderer-independent checkbox state.
+ * @remarks
+ * ## Why
+ * State transitions remain testable without rendering and can be consumed by
+ * any UI producer.
+ * ## Ownership and lifetime
+ * The caller's Effect Scope owns the hydrated RefSubject and its subscriptions.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   return yield* Checkbox.makeState({ checked: "mixed" })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function makeState(initial?: InitialState): Effect.Effect<RefSubject.HydratedRefSubject<{
+    readonly checked: "mixed" | boolean;
+}, Schema.SchemaError, never, never>, never, import("effect/Scope").Scope>;
+/** Sets the checkbox state to a boolean or mixed value.
+ * @remarks
+ * ## Why
+ * A single atomic RefSubject update keeps DOM properties and ARIA state aligned.
+ * ## Ownership and lifetime
+ * The Effect uses the existing subject lifetime and acquires no new resource.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Checkbox.makeState()
+ *   yield* Checkbox.setChecked(state, true)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category state
+ */
+export declare function setChecked<E, R>(state: RefSubject.RefSubject<State, E, R>, checked: Checked): Effect.Effect<State, E, R>;
+/** Toggles checked to false and false or mixed to true.
+ * @remarks
+ * ## Why
+ * User activation of an indeterminate checkbox resolves to a concrete checked
+ * state, matching native input behavior.
+ * ## Ownership and lifetime
+ * The Effect updates the existing RefSubject and acquires no resource.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Checkbox.makeState({ checked: "mixed" })
+ *   yield* Checkbox.toggle(state)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category state
+ */
+export declare function toggle<E, R>(state: RefSubject.RefSubject<State, E, R>): Effect.Effect<State, E, R>;
+/** Options for the native checkbox input.
+ * @remarks
+ * ## Why
+ * The state reference is the single source for native and ARIA checked values.
+ * ## Ownership and lifetime
+ * Options are inert; the component Scope owns DOM subscriptions and refs.
+ * @since 1.0.0
+ * @category models
+ */
+export interface InputOptions extends Dom.HostOptions<HTMLInputElement> {
+    /** Hydrated state synchronized with the input.
+     * @remarks
+     * ## Why
+     * Hydration preserves checked identity and enables state-only tests.
+     * ## Ownership and lifetime
+     * The input borrows the RefSubject; its original Scope remains the owner.
+     * @since 1.0.0
+     * @category state
+     */
+    readonly state: RefSubject.HydratedRefSubject<State, Schema.SchemaError>;
+}
+declare function internalProps<const Options extends InputOptions>(options: Options): ({ property }: Dom.InternalPropsHelpers<Options>) => {
+    type: string;
+    "aria-checked": RefSubject.Computed<Checked, Schema.SchemaError, never>;
+    "?checked": RefSubject.Computed<boolean, Schema.SchemaError, never>;
+    ".checked": RefSubject.Computed<boolean, Schema.SchemaError, never>;
+    "?disabled": false | Exclude<Dom.Property<Options, "disabled">, Dom.Nullish>;
+    "?required": false | Exclude<Dom.Property<Options, "required">, Dom.Nullish>;
+    ".indeterminate": RefSubject.Computed<boolean, Schema.SchemaError, never>;
+    onchange: EventHandler.EventHandler<Event, Schema.SchemaError, never>;
+    ref: RefSubject.HydratedRefSubject<State, Schema.SchemaError, never, never>;
+};
+type InputInternalProps<Options extends InputOptions> = ReturnType<ReturnType<typeof internalProps<Options>>>;
+/** Renders a native checkbox input synchronized with hydrated state.
+ * @remarks
+ * ## Why
+ * Native keyboard, form, disabled, required, and accessibility behavior remain
+ * available while state is exposed through RefSubject.
+ * ## Ownership and lifetime
+ * Running the Fx installs native listeners and state subscriptions in its
+ * Scope. A custom host must apply `type`, checked, indeterminate, ARIA, and ref
+ * props; only one hydration owner may be composed for the element.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Checkbox.makeState()
+ *   return Checkbox.Input({ state })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export declare function Input<const Options extends InputOptions, const Host extends HostResult = never>(options: Options, host?: Dom.HostOverride<Dom.RenderHostProps<Options, InputInternalProps<Options>>, "", Host>): import("./Dom/Types.js").HostComponent<Host | Options>;
+/** Canonical component alias for `Input`.
+ * @remarks
+ * ## Why
+ * The alias provides the widget name while retaining the explicit input API.
+ * ## Ownership and lifetime
+ * It has exactly the same Scope and native-element ownership as `Input`.
+ * @since 1.0.0
+ * @category aliases
+ */
+export declare const Checkbox: typeof Input;
+export {};
+//# sourceMappingURL=Checkbox.d.ts.map

package/dist/Checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checkbox.d.ts","sourceRoot":"","sources":["../src/Checkbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,YAAY,EAAQ,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;;GASG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAExC;;;;;;;;;GASG;AACH,MAAM,WAAW,KAAK;IACpB;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;EAEtB,CAAC;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,YAAiB;;2EAEnD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,EACzC,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAE5B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,GACxC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAK5B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAa,SAAQ,GAAG,CAAC,WAAW,CAAC,gBAAgB,CAAC;IACrE;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;CAC1E;AAED,iBAAS,aAAa,CAAC,KAAK,CAAC,OAAO,SAAS,YAAY,EAAE,OAAO,EAAE,OAAO,kBASnD,GAAG,CAAC,oBAAoB,CAAC,OAAO,CAAC;IACrD,IAAI;IACJ,cAAc;IACd,UAAU;IACV,UAAU;IACV,WAAW;IACX,WAAW;IACX,gBAAgB;IAChB,QAAQ;IACR,GAAG;EAEN;AAED,KAAK,kBAAkB,CAAC,OAAO,SAAS,YAAY,IAAI,UAAU,CAChE,UAAU,CAAC,OAAO,aAAa,CAAC,OAAO,CAAC,CAAC,CAC1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,KAAK,CAAC,OAAO,SAAS,YAAY,EAAE,KAAK,CAAC,IAAI,SAAS,UAAU,GAAG,KAAK,EAC7F,OAAO,EAAE,OAAO,EAChB,IAAI,CAAC,EAAE,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,0DAW7F;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,cAAQ,CAAC"}