@elaraai/east-ui 1.0.3 → 1.0.5

package/dist/src/collections/blend/index.d.ts

@@ -0,0 +1,525 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `Blend` — the assembly surface for blending / batching decisions: pull
+ * amounts from many sources into one or more targets ("what proportion of
+ * what"). Pairs with a `Library` on the left; one pattern, three render
+ * modes by target count — `single` focus, `compare` with the derived diff
+ * table, `portfolio` horizontal scroll.
+ *
+ * @packageDocumentation
+ */
+import { type ExprType, type SubtypeExprOrValue, type TypeOf, ArrayType, type BooleanType, FloatType, type FunctionType, type NullType, StringType, StructType } from "@elaraai/east";
+import { UIComponentType } from "../../component.js";
+import { type DragEventType } from "../../contracts/drag.js";
+import { PlannerStateType } from "../planner/types.js";
+import { BlendAllocationType, BlendMetricType, BlendAmountEventType, BlendActionEventType } from "./types.js";
+export { BlendRootType, BlendTargetType, BlendAllocationType, BlendMetricType, BlendActionType, BlendAmountEventType, BlendActionEventType, } from "./types.js";
+/**
+ * The struct element type of a `SubtypeExprOrValue<ArrayType<StructType>>`.
+ */
+export type RowElement<T extends SubtypeExprOrValue<ArrayType<StructType>>> = TypeOf<T> extends ArrayType<infer S> ? (S extends StructType ? S : never) : never;
+/**
+ * Fields accepted by {@link allocation}.
+ *
+ * @property source - Source identity (a Library item key when paired)
+ * @property label - Row label (defaults to the source key)
+ * @property sublabel - Optional muted second line (class / site)
+ * @property amount - Allocated amount, in the target's unit
+ * @property pinned - Held fixed — excluded from drag-out (default false)
+ * @property state - The audit state (default committed)
+ */
+export interface BlendAllocationFields {
+    /** Source identity (a Library item key when paired). */
+    source: SubtypeExprOrValue<StringType>;
+    /** Row label (defaults to the source key). */
+    label?: SubtypeExprOrValue<StringType>;
+    /** Optional muted second line (class / site). */
+    sublabel?: SubtypeExprOrValue<StringType>;
+    /** Allocated amount, in the target's unit. */
+    amount: SubtypeExprOrValue<FloatType>;
+    /** Held fixed — excluded from drag-out (default false). */
+    pinned?: SubtypeExprOrValue<BooleanType>;
+    /** The audit state (default committed). */
+    state?: SubtypeExprOrValue<PlannerStateType>;
+}
+/**
+ * Builds one allocation value — usable inside expressions (e.g. inside a
+ * `t.allocations.map(...)` callback).
+ *
+ * @param fields - Allocation fields ({@link BlendAllocationFields})
+ * @returns An East expression of `BlendAllocationType`
+ *
+ * @example
+ * ```ts
+ * Blend.allocation({ source: a.sourceId, amount: a.amount, state: a.state })
+ * ```
+ */
+declare function allocation(fields: BlendAllocationFields): ExprType<BlendAllocationType>;
+/**
+ * Fields accepted by {@link metric}.
+ *
+ * @property key - Metric identity — referenced by the compare `diff` list
+ * @property label - Row label (e.g. `cost / unit`)
+ * @property value - Display text (host-formatted, e.g. `$3.42`)
+ * @property numeric - Optional numeric value — drives the compare Δ column
+ * @property model - Optional trust-chip model id (e.g. `cost-v1.4`)
+ * @property band - Optional confidence band
+ */
+export interface BlendMetricFields {
+    /** Metric identity — referenced by the compare `diff` list. */
+    key: SubtypeExprOrValue<StringType>;
+    /** Row label (e.g. `cost / unit`). */
+    label: SubtypeExprOrValue<StringType>;
+    /** Display text (host-formatted, e.g. `$3.42`). */
+    value: SubtypeExprOrValue<StringType>;
+    /** Optional numeric value — drives the compare Δ column. */
+    numeric?: SubtypeExprOrValue<FloatType>;
+    /** Optional trust-chip model id (e.g. `cost-v1.4`). */
+    model?: SubtypeExprOrValue<StringType>;
+    /** Optional confidence band. */
+    band?: {
+        min: SubtypeExprOrValue<FloatType>;
+        max: SubtypeExprOrValue<FloatType>;
+    };
+}
+/**
+ * Builds one metric row value — usable inside expressions.
+ *
+ * @param fields - Metric fields ({@link BlendMetricFields})
+ * @returns An East expression of `BlendMetricType`
+ *
+ * @example
+ * ```ts
+ * Blend.metric({ key: "cost", label: "cost / unit", value: East.str`$${t.cost}`, numeric: t.cost, model: "cost-v1.4" })
+ * ```
+ */
+declare function metric(fields: BlendMetricFields): ExprType<BlendMetricType>;
+/**
+ * Fields the `target` mapper returns — one target panel, before defaults.
+ *
+ * @property key - Target identity
+ * @property label - Panel title
+ * @property capacity - Full capacity, in `unit`
+ * @property unit - Display unit (default `u`)
+ * @property objective - Optional objective line text
+ * @property allocations - The allocations (`Blend.allocation(...)` values)
+ * @property metrics - Predicted metric rows (`Blend.metric(...)` values)
+ */
+export interface BlendTargetFields {
+    /** Target identity. */
+    key: SubtypeExprOrValue<StringType>;
+    /** Panel title. */
+    label: SubtypeExprOrValue<StringType>;
+    /** Full capacity, in `unit`. */
+    capacity: SubtypeExprOrValue<FloatType>;
+    /** Display unit (default `u`). */
+    unit?: SubtypeExprOrValue<StringType>;
+    /** Optional objective line text. */
+    objective?: SubtypeExprOrValue<StringType>;
+    /** The allocations (`Blend.allocation(...)` values). */
+    allocations: SubtypeExprOrValue<ArrayType<BlendAllocationType>>;
+    /** Predicted metric rows (`Blend.metric(...)` values). */
+    metrics?: SubtypeExprOrValue<ArrayType<BlendMetricType>>;
+}
+/**
+ * Configuration for {@link createBlend}.
+ *
+ * @typeParam R - The target row struct
+ * @property id - DnD target identity
+ * @property sources - Library ids accepted for `add` drags (omit = no adds)
+ * @property target - Target row mapper (omit when rows are already resolved)
+ * @property diff - Compare mode: metric keys for the foot table (default all)
+ * @property verdict - Optional compare verdict line
+ * @property onDrag - Drag funnel — add / remove events
+ * @property onAmountChange - Allocation amount edits
+ * @property onAction - Panel actions (reset / apply / discard)
+ */
+export interface BlendConfig<R extends StructType> {
+    /** DnD target identity. */
+    id: string;
+    /** Library ids accepted for `add` drags (omit = no adds). */
+    sources?: string[];
+    /** Target row mapper; omit when `targets` is already `ArrayType(Blend.Types.Target)`. */
+    target?: (target: ExprType<R>) => BlendTargetFields;
+    /** Compare mode: metric keys for the foot table (default all). */
+    diff?: string[];
+    /** Optional compare verdict line. */
+    verdict?: SubtypeExprOrValue<StringType>;
+    /** Drag funnel — add / remove events. */
+    onDrag?: SubtypeExprOrValue<FunctionType<[DragEventType], NullType>>;
+    /** Allocation amount edits. */
+    onAmountChange?: SubtypeExprOrValue<FunctionType<[BlendAmountEventType], NullType>>;
+    /** Panel actions (reset / apply / discard). */
+    onAction?: SubtypeExprOrValue<FunctionType<[BlendActionEventType], NullType>>;
+}
+/**
+ * Creates a Blend — the assembly surface for blending / batching decisions.
+ *
+ * @typeParam T - The targets-table input
+ * @param targets - The target rows (length picks the render mode: 1 single, 2 compare, 3+ portfolio)
+ * @param config - The Blend configuration ({@link BlendConfig})
+ * @returns An East expression of `UIComponentType`
+ *
+ * @example
+ * ```ts
+ * import { East } from "@elaraai/east";
+ * import { Blend, UIComponentType } from "@elaraai/east-ui";
+ *
+ * const example = East.function([], UIComponentType, _$ =>
+ *     Blend.Root(
+ *         [{ key: "BLEND-318", name: "Blend 318", cap: 40000.0 }],
+ *         {
+ *             id: "bench",
+ *             sources: ["materials"],
+ *             target: t => ({
+ *                 key: t.key, label: t.name, capacity: t.cap,
+ *                 allocations: [Blend.allocation({ source: "LOT-204", amount: 16000.0 })],
+ *             }),
+ *         },
+ *     ),
+ * );
+ * ```
+ */
+declare function createBlend<T extends SubtypeExprOrValue<ArrayType<StructType>>>(targets: T, config: BlendConfig<RowElement<T>>): ExprType<UIComponentType>;
+/**
+ * Blend component namespace.
+ *
+ * @remarks
+ * `Blend.Root(targets, config)` builds the surface; `Blend.allocation` /
+ * `Blend.metric` build the expression-level row values; allocation states
+ * reuse the shared event-state grammar (`Blend.Types.State`).
+ */
+export declare const Blend: {
+    /**
+     * Creates a Blend — the assembly surface for blending / batching
+     * decisions, with the drag & drop target role (`add` / `remove`).
+     *
+     * @typeParam T - The targets-table input
+     * @param targets - The target rows (1 = single, 2 = compare, 3+ = portfolio)
+     * @param config - The Blend configuration ({@link BlendConfig})
+     * @returns An East expression of `UIComponentType`
+     *
+     * @remarks
+     * The compare diff table and Δ column are derived by the renderer from
+     * the two targets' metrics (`numeric` field) — the host doesn't compute
+     * the comparison. Optimisation is precalculated upstream — proposals
+     * arrive in the data; the component never triggers computation.
+     *
+     * @example
+     * ```ts
+     * import { East } from "@elaraai/east";
+     * import { Blend, UIComponentType } from "@elaraai/east-ui";
+     *
+     * const example = East.function([], UIComponentType, _$ =>
+     *     Blend.Root(
+     *         [{ key: "BLEND-318", name: "Blend 318", cap: 40000.0 }],
+     *         {
+     *             id: "bench",
+     *             target: t => ({
+     *                 key: t.key, label: t.name, capacity: t.cap,
+     *                 allocations: [Blend.allocation({ source: "LOT-204", amount: 16000.0 })],
+     *             }),
+     *         },
+     *     ),
+     * );
+     * ```
+     */
+    readonly Root: typeof createBlend;
+    /**
+     * Builds one allocation value — usable inside expressions.
+     *
+     * @param fields - Allocation fields ({@link BlendAllocationFields})
+     * @returns An East expression of `BlendAllocationType`
+     *
+     * @example
+     * ```ts
+     * Blend.allocation({ source: a.sourceId, amount: a.amount, pinned: a.pinned, state: a.state })
+     * ```
+     */
+    readonly allocation: typeof allocation;
+    /**
+     * Builds one metric row value — usable inside expressions.
+     *
+     * @param fields - Metric fields ({@link BlendMetricFields})
+     * @returns An East expression of `BlendMetricType`
+     *
+     * @example
+     * ```ts
+     * Blend.metric({ key: "grade", label: "predicted grade", value: t.grade, model: "blend-v2.1" })
+     * ```
+     */
+    readonly metric: typeof metric;
+    readonly Types: {
+        /**
+         * East StructType for the Blend component.
+         *
+         * @remarks
+         * See {@link BlendRootType} for per-field docs.
+         *
+         * @property id - DnD target identity
+         * @property sources - Library ids accepted for `add`
+         * @property targets - The target panels
+         * @property diff - Compare-mode metric keys
+         * @property verdict - Optional compare verdict line
+         * @property onDrag - Drag funnel
+         * @property onAmountChange - Amount edits
+         * @property onAction - Panel actions
+         */
+        readonly Blend: StructType<{
+            readonly id: StringType;
+            readonly sources: ArrayType<StringType>;
+            readonly targets: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly capacity: FloatType;
+                readonly unit: StringType;
+                readonly objective: import("@elaraai/east").OptionType<StringType>;
+                readonly allocations: ArrayType<StructType<{
+                    readonly source: StringType;
+                    readonly label: StringType;
+                    readonly sublabel: import("@elaraai/east").OptionType<StringType>;
+                    readonly amount: FloatType;
+                    readonly pinned: BooleanType;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        readonly committed: NullType;
+                        readonly proposed: import("@elaraai/east").VariantType<{
+                            readonly added: NullType;
+                            readonly model: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly rejected: NullType;
+                    }>;
+                }>>;
+                readonly metrics: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly label: StringType;
+                    readonly value: StringType;
+                    readonly numeric: import("@elaraai/east").OptionType<FloatType>;
+                    readonly model: import("@elaraai/east").OptionType<StringType>;
+                    readonly band: import("@elaraai/east").OptionType<StructType<{
+                        readonly min: FloatType;
+                        readonly max: FloatType;
+                    }>>;
+                }>>;
+            }>>;
+            readonly diff: ArrayType<StringType>;
+            readonly verdict: import("@elaraai/east").OptionType<StringType>;
+            readonly onDrag: import("@elaraai/east").OptionType<FunctionType<[import("@elaraai/east").VariantType<{
+                readonly add: StructType<{
+                    readonly from: StructType<{
+                        readonly library: StringType;
+                        readonly key: StringType;
+                    }>;
+                    readonly into: StructType<{
+                        readonly surface: StringType;
+                        readonly row: StringType;
+                        readonly slot: StringType;
+                        readonly event: import("@elaraai/east").OptionType<StringType>;
+                    }>;
+                    readonly duplicate: BooleanType;
+                }>;
+                readonly move: StructType<{
+                    readonly from: StructType<{
+                        readonly surface: StringType;
+                        readonly row: StringType;
+                        readonly slot: StringType;
+                        readonly event: import("@elaraai/east").OptionType<StringType>;
+                    }>;
+                    readonly to: StructType<{
+                        readonly surface: StringType;
+                        readonly row: StringType;
+                        readonly slot: StringType;
+                        readonly event: import("@elaraai/east").OptionType<StringType>;
+                    }>;
+                }>;
+                readonly remove: StructType<{
+                    readonly from: StructType<{
+                        readonly surface: StringType;
+                        readonly row: StringType;
+                        readonly slot: StringType;
+                        readonly event: import("@elaraai/east").OptionType<StringType>;
+                    }>;
+                    readonly to: import("@elaraai/east").VariantType<{
+                        readonly trash: NullType;
+                        readonly source: NullType;
+                    }>;
+                }>;
+                readonly resize: StructType<{
+                    readonly event: StructType<{
+                        readonly surface: StringType;
+                        readonly row: StringType;
+                        readonly slot: StringType;
+                        readonly event: import("@elaraai/east").OptionType<StringType>;
+                    }>;
+                    readonly edge: import("@elaraai/east").VariantType<{
+                        readonly start: NullType;
+                        readonly end: NullType;
+                    }>;
+                }>;
+            }>], NullType>>;
+            readonly onAmountChange: import("@elaraai/east").OptionType<FunctionType<[StructType<{
+                readonly target: StringType;
+                readonly source: StringType;
+                readonly amount: FloatType;
+            }>], NullType>>;
+            readonly onAction: import("@elaraai/east").OptionType<FunctionType<[StructType<{
+                readonly target: import("@elaraai/east").OptionType<StringType>;
+                readonly action: import("@elaraai/east").VariantType<{
+                    readonly reset: NullType;
+                    readonly apply: NullType;
+                    readonly discard: NullType;
+                }>;
+            }>], NullType>>;
+        }>;
+        /**
+         * One blend target panel.
+         *
+         * @property key - Target identity
+         * @property label - Panel title
+         * @property capacity - Full capacity
+         * @property unit - Display unit
+         * @property objective - Optional objective line
+         * @property allocations - The source allocations
+         * @property metrics - Predicted metric rows
+         */
+        readonly Target: StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly capacity: FloatType;
+            readonly unit: StringType;
+            readonly objective: import("@elaraai/east").OptionType<StringType>;
+            readonly allocations: ArrayType<StructType<{
+                readonly source: StringType;
+                readonly label: StringType;
+                readonly sublabel: import("@elaraai/east").OptionType<StringType>;
+                readonly amount: FloatType;
+                readonly pinned: BooleanType;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly committed: NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: NullType;
+                        readonly model: NullType;
+                        readonly removed: NullType;
+                    }>;
+                    readonly rejected: NullType;
+                }>;
+            }>>;
+            readonly metrics: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly value: StringType;
+                readonly numeric: import("@elaraai/east").OptionType<FloatType>;
+                readonly model: import("@elaraai/east").OptionType<StringType>;
+                readonly band: import("@elaraai/east").OptionType<StructType<{
+                    readonly min: FloatType;
+                    readonly max: FloatType;
+                }>>;
+            }>>;
+        }>;
+        /**
+         * One source allocation.
+         *
+         * @property source - Source identity
+         * @property label - Row label
+         * @property sublabel - Optional muted second line
+         * @property amount - Allocated amount
+         * @property pinned - Excluded from optimise / drag-out
+         * @property state - The audit state
+         */
+        readonly Allocation: StructType<{
+            readonly source: StringType;
+            readonly label: StringType;
+            readonly sublabel: import("@elaraai/east").OptionType<StringType>;
+            readonly amount: FloatType;
+            readonly pinned: BooleanType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly committed: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly model: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly rejected: NullType;
+            }>;
+        }>;
+        /**
+         * A predicted metric row.
+         *
+         * @property key - Metric identity
+         * @property label - Row label
+         * @property value - Display text
+         * @property numeric - Optional numeric value (compare Δ)
+         * @property model - Optional trust-chip model id
+         * @property band - Optional confidence band
+         */
+        readonly Metric: StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly value: StringType;
+            readonly numeric: import("@elaraai/east").OptionType<FloatType>;
+            readonly model: import("@elaraai/east").OptionType<StringType>;
+            readonly band: import("@elaraai/east").OptionType<StructType<{
+                readonly min: FloatType;
+                readonly max: FloatType;
+            }>>;
+        }>;
+        /**
+         * A target-panel action (`reset` / `apply` / `discard`).
+         *
+         * @property reset - Revert proposed changes
+         * @property apply - Commit the blend
+         * @property discard - Drop a compare candidate
+         */
+        readonly Action: import("@elaraai/east").VariantType<{
+            readonly reset: NullType;
+            readonly apply: NullType;
+            readonly discard: NullType;
+        }>;
+        /**
+         * The `onAmountChange` payload.
+         *
+         * @property target - Target key
+         * @property source - Allocation source key
+         * @property amount - The edited amount
+         */
+        readonly AmountEvent: StructType<{
+            readonly target: StringType;
+            readonly source: StringType;
+            readonly amount: FloatType;
+        }>;
+        /**
+         * The `onAction` payload.
+         *
+         * @property target - The target key, or `none` for surface-wide actions
+         * @property action - Which action fired
+         */
+        readonly ActionEvent: StructType<{
+            readonly target: import("@elaraai/east").OptionType<StringType>;
+            readonly action: import("@elaraai/east").VariantType<{
+                readonly reset: NullType;
+                readonly apply: NullType;
+                readonly discard: NullType;
+            }>;
+        }>;
+        /**
+         * The shared event-state grammar (committed / proposed / rejected).
+         *
+         * @property committed - A committed allocation
+         * @property proposed - A proposal (`added` / `model` / `removed`)
+         * @property rejected - A rejected proposal
+         */
+        readonly State: import("@elaraai/east").VariantType<{
+            readonly committed: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly model: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly rejected: NullType;
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/collections/blend/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/collections/blend/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AAEH,OAAO,EACH,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACvB,KAAK,MAAM,EAMX,SAAS,EACT,KAAK,WAAW,EAChB,SAAS,EACT,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,UAAU,EACV,UAAU,EACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAGH,mBAAmB,EACnB,eAAe,EAEf,oBAAoB,EACpB,oBAAoB,EACvB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACH,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,oBAAoB,GACvB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,IACtE,MAAM,CAAC,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,UAAU,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC;AAMtF;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IAClC,wDAAwD;IACxD,MAAM,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACvC,8CAA8C;IAC9C,KAAK,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACvC,iDAAiD;IACjD,QAAQ,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IAC1C,8CAA8C;IAC9C,MAAM,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACtC,2DAA2D;IAC3D,MAAM,CAAC,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;IACzC,2CAA2C;IAC3C,KAAK,CAAC,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;CAChD;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,UAAU,CAAC,MAAM,EAAE,qBAAqB,GAAG,QAAQ,CAAC,mBAAmB,CAAC,CAShF;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IAC9B,+DAA+D;IAC/D,GAAG,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACpC,sCAAsC;IACtC,KAAK,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACtC,mDAAmD;IACnD,KAAK,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACtC,4DAA4D;IAC5D,OAAO,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACxC,uDAAuD;IACvD,KAAK,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACvC,gCAAgC;IAChC,IAAI,CAAC,EAAE;QAAE,GAAG,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;QAAC,GAAG,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAA;KAAE,CAAC;CACrF;AAED;;;;;;;;;;GAUG;AACH,iBAAS,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,QAAQ,CAAC,eAAe,CAAC,CAYpE;AAMD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAC9B,uBAAuB;IACvB,GAAG,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACpC,mBAAmB;IACnB,KAAK,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACtC,gCAAgC;IAChC,QAAQ,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACxC,kCAAkC;IAClC,IAAI,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACtC,oCAAoC;IACpC,SAAS,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IAC3C,wDAAwD;IACxD,WAAW,EAAE,kBAAkB,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC,CAAC;IAChE,0DAA0D;IAC1D,OAAO,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC,CAAC;CAC5D;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,UAAU;IAC7C,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,yFAAyF;IACzF,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC;IACpD,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,qCAAqC;IACrC,OAAO,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACzC,yCAAyC;IACzC,MAAM,CAAC,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IACrE,+BAA+B;IAC/B,cAAc,CAAC,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IACpF,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;CACjF;AAqCD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iBAAS,WAAW,CAAC,CAAC,SAAS,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,EACpE,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GACnC,QAAQ,CAAC,eAAe,CAAC,CAE3B;AAMD;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;;IAEH;;;;;;;;;;OAUG;;IAEH;;;;;;;;;;OAUG;;;QAGC;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEH;;;;;;;;;;WAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEH;;;;;;;;;WASG;;;;;;;;;;;;;;;;;QAEH;;;;;;;;;WASG;;;;;;;;;;;;QAEH;;;;;;WAMG;;;;;;QAEH;;;;;;WAMG;;;;;;QAEH;;;;;WAKG;;;;;;;;;QAEH;;;;;;WAMG;;;;;;;;;;;CAGD,CAAC"}