@raintonic/formaui 0.2.0

package/types/raintonic-formaui-components-checkbox.d.ts

@@ -0,0 +1,132 @@
+import * as _angular_core from '@angular/core';
+import { DoCheck, OnDestroy, OutputEmitterRef, Signal, ElementRef } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { ErrorStateMatcher } from '@raintonic/formaui/core';
+
+/**
+ * Checkbox label position
+ */
+type FuiCheckboxLabelPosition = 'before' | 'after';
+/**
+ * Checkbox change event interface (compatible with MatCheckboxChange)
+ */
+interface FuiCheckboxChange {
+    /** The source checkbox of the event. */
+    source: FuiCheckboxComponent;
+    /** The new `checked` value of the checkbox. */
+    checked: boolean;
+}
+/**
+ * # FuiCheckbox Component
+ *
+ * A checkbox component with full Angular Reactive Forms support.
+ * Compatible with Angular Material's mat-checkbox interface.
+ *
+ * ## Features
+ * - Full Reactive Forms integration (ControlValueAccessor)
+ * - Indeterminate state support
+ * - Label position configuration (before/after)
+ * - Built-in validation and error display
+ * - Disabled state
+ * - Full accessibility support (ARIA)
+ * - Compatible with mat-checkbox interface
+ *
+ * ## Usage
+ *
+ * ### Basic Checkbox
+ * ```html
+ * <fui-checkbox>Accept terms</fui-checkbox>
+ * ```
+ *
+ * ### With Reactive Forms
+ * ```html
+ * <form [formGroup]="form">
+ *   <fui-checkbox formControlName="acceptTerms">
+ *     I accept the terms and conditions
+ *   </fui-checkbox>
+ * </form>
+ * ```
+ *
+ * ### Indeterminate State
+ * ```html
+ * <fui-checkbox [indeterminate]="true">
+ *   Select all
+ * </fui-checkbox>
+ * ```
+ *
+ * ### Label Position
+ * ```html
+ * <fui-checkbox labelPosition="before">
+ *   Label before checkbox
+ * </fui-checkbox>
+ * ```
+ */
+declare class FuiCheckboxComponent implements ControlValueAccessor, DoCheck, OnDestroy {
+    static nextId: number;
+    readonly controlType = "fui-checkbox";
+    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly indeterminateInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly requiredInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly labelPosition: _angular_core.InputSignal<FuiCheckboxLabelPosition>;
+    readonly name: _angular_core.InputSignal<string | null>;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    readonly disableRipple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly tabIndex: _angular_core.InputSignal<number>;
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | null>;
+    readonly change: OutputEmitterRef<FuiCheckboxChange>;
+    readonly indeterminateChange: OutputEmitterRef<boolean>;
+    private readonly _checked;
+    private readonly _indeterminate;
+    private readonly _focused;
+    private readonly _disabled;
+    readonly checked: Signal<boolean>;
+    readonly indeterminate: Signal<boolean>;
+    readonly focused: Signal<boolean>;
+    readonly stateChanges: Subject<void>;
+    private _uid;
+    readonly id: string;
+    readonly inputId: string;
+    private readonly _errorState;
+    readonly errorState: Signal<boolean>;
+    private _parentForm;
+    private _parentFormGroup;
+    private _defaultErrorStateMatcher;
+    private readonly _ngControlRef;
+    get ngControl(): NgControl | null;
+    private readonly _required;
+    readonly required: Signal<boolean>;
+    private readonly _ngControlDisabled;
+    readonly disabled: Signal<boolean>;
+    readonly inputElement: Signal<ElementRef<HTMLInputElement> | undefined>;
+    private _onChange;
+    private _onTouched;
+    private _formControlInitialized;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInputChange(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    /** Toggles the `checked` state of the checkbox. */
+    toggle(): void;
+    /** Focuses the checkbox. */
+    focus(): void;
+    /** Sets the indeterminate state programmatically. */
+    setIndeterminate(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiCheckboxComponent, "fui-checkbox", never, { "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "indeterminateInput": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, never, ["*", "*"], true, never>;
+}
+
+export { FuiCheckboxComponent };
+export type { FuiCheckboxChange, FuiCheckboxLabelPosition };
+//# sourceMappingURL=raintonic-formaui-components-checkbox.d.ts.map

package/types/raintonic-formaui-components-checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-checkbox.d.ts","sources":["../../../lib/components/checkbox/checkbox.component.ts"],"mappings":";;;;;;AAyBA;;AAEG;KACS,wBAAwB;AAEpC;;AAEG;UACc,iBAAiB;;YAExB,oBAAoB;;;AAG7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CG;AACH,cA4Ba,oBAAqB,YAAW,oBAAoB,EAAE,OAAO,EAAE,SAAS;;;4BAM7D,aAAA,CAAA,wBAAA;2BAID,aAAA,CAAA,wBAAA;4BAIC,aAAA,CAAA,wBAAA;iCAIK,aAAA,CAAA,wBAAA;4BAIL,aAAA,CAAA,wBAAA;4BAIA,aAAA,CAAA,WAAA,CAAA,wBAAA;mBACT,aAAA,CAAA,WAAA;oBACC,aAAA,CAAA,WAAA;wBACI,aAAA,CAAA,WAAA;6BACK,aAAA,CAAA,WAAA;8BACC,aAAA,CAAA,WAAA;4BACF,aAAA,CAAA,wBAAA;uBACL,aAAA,CAAA,WAAA;gCACS,aAAA,CAAA,WAAA,CAAA,iBAAA;AAG1B,qBAAiB,gBAAgB,CAAC,iBAAiB;AACnD,kCAA8B,gBAAgB;AAG9C;AACA;AACA;AACA;AAGA,sBAAkB,MAAM;AACxB,4BAAwB,MAAM;AAC9B,sBAAkB,MAAM;2BAGH,OAAA;;;;AAMrB;yBACmB,MAAA;;;;AAMnB;AAEA,qBAAiB,SAAS;AAK1B;AACA,uBAAmB,MAAM;AAGzB;AACA,uBAAmB,MAAM;AAKzB,2BAAuB,MAAM,CAAC,UAAU,CAAC,gBAAgB;;;;;AA8DzD;AAgBA;AAKA;;AAUA;AAIA;AAMA,yBAAqB,KAAK;AA6B1B;AAOA;;AAWA;;AAqBA;;AAKA;oDAlQW,oBAAoB;sDAApB,oBAAoB;AAyQhC;;;;","names":[]}

package/types/raintonic-formaui-components-data-table.d.ts

@@ -0,0 +1,368 @@
+import * as _angular_core from '@angular/core';
+import { FuiMenuComponent } from '@raintonic/formaui/components/menu';
+
+/**
+ * Label configuration for badge rendering in table cells.
+ * Mirrors IIndexConfigurationLabel from @zero/api-models — duplicated
+ * intentionally because FormaUI cannot depend on api-models.
+ */
+interface AdvancedDataTableLabelConfig {
+    value: string;
+    label: string;
+    color: string;
+    icon?: string;
+}
+/**
+ * Configuration for a table header column
+ */
+interface AdvancedDataTableHeader {
+    /**
+     * Whether this column should be sticky at the start
+     * Only applies to columns at the start of the array until first false is encountered
+     */
+    stickyColumnStart?: boolean;
+    /**
+     * Whether this column should be sticky at the end
+     * First true value makes all following columns sticky
+     */
+    stickyColumnEnd?: boolean;
+    /**
+     * Display label for the column header
+     */
+    label: string;
+    /**
+     * Data type of the column (e.g., 'string', 'number', 'date', 'boolean')
+     */
+    type: string;
+    /**
+     * Property path in the data object (e.g., 'user.name', 'address.city')
+     * Format: <entityName>.<property>, can have multiple levels for nested objects
+     */
+    field: string;
+    /**
+     * Whether this column supports sorting
+     */
+    hasSort?: boolean;
+    /**
+     * Whether this column supports filtering
+     */
+    hasFilter?: boolean;
+    labels?: AdvancedDataTableLabelConfig[];
+}
+/**
+ * Configuration for the advanced data table
+ */
+/**
+ * Processed header with computed sticky positioning
+ */
+interface ProcessedDataTableHeader extends AdvancedDataTableHeader {
+    isStartSticky: boolean;
+    isEndSticky: boolean;
+    isLastStartSticky: boolean;
+    isFirstEndSticky: boolean;
+    startStickyPosition: number;
+    endStickyPosition: number;
+}
+interface AdvancedDataTableConfig {
+    /**
+     * Whether the table header should be sticky
+     */
+    headerSticky?: boolean;
+    /**
+     * Array of header column configurations
+     */
+    headers: AdvancedDataTableHeader[];
+    /**
+     * Whether rows can be selected via checkboxes
+     */
+    areRowsSelectable?: boolean;
+}
+/**
+ * Filter operator types
+ */
+declare enum FilterOperator {
+    CONTAINS = "CONTAINS",
+    START_WITH = "START_WITH",
+    END_WITH = "END_WITH",
+    EQUAL = "EQUAL",
+    NOT_EQUAL = "NOT_EQUAL",
+    GREATER = "GREATER",
+    GREATER_EQUAL = "GREATER_EQUAL",
+    LOWER = "LOWER",
+    LOWER_EQUAL = "LOWER_EQUAL",
+    BETWEEN = "BETWEEN",
+    IS_TRUE = "IS_TRUE",
+    IS_FALSE = "IS_FALSE"
+}
+/**
+ * Filter configuration for a column
+ */
+interface ColumnFilter {
+    field: string;
+    operator: FilterOperator;
+    value: string | number | boolean | Date | (string | number | Date)[];
+}
+/**
+ * Filter operator option
+ */
+interface FilterOperatorOption {
+    value: FilterOperator;
+    label: string;
+    requiresInput: boolean;
+    requiresSecondInput: boolean;
+}
+/**
+ * @component FuiAdvancedDataTableComponent
+ * @selector fui-advanced-data-table
+ * @description A feature-rich data table with configurable columns, sticky headers/columns,
+ * row selection via checkboxes, sorting, column filtering, row highlighting, and badge-based label rendering.
+ *
+ * @input config - (required) Table configuration including headers, sticky settings, and row selectability.
+ * @input data - Array of row data objects. Default [].
+ * @input enableRowHighlight - Whether clicking a row toggles highlight. Default false.
+ * @input tableAriaLabel - Accessible label for the table element. Default 'Data table'.
+ * @input emptyMessage - Message shown when data is empty. Default 'Nessun dato disponibile'.
+ * @input sort - Current sort state: { field, direction } or null.
+ * @input filters - Array of active column filters.
+ * @output sortChange - Emits when the user changes sort direction on a column.
+ * @output filtersChange - Emits when filters are applied or cleared.
+ * @output rowDblClick - Emits the row data object on double-click.
+ *
+ * @example
+ * <fui-advanced-data-table
+ *   [config]="tableConfig"
+ *   [data]="rows"
+ *   [sort]="currentSort"
+ *   (sortChange)="onSort($event)"
+ *   (filtersChange)="onFilter($event)"
+ *   (rowDblClick)="onRowOpen($event)">
+ * </fui-advanced-data-table>
+ */
+declare class FuiAdvancedDataTableComponent<T = Record<string, unknown>> {
+    /**
+     * Table configuration
+     */
+    readonly config: _angular_core.InputSignal<AdvancedDataTableConfig>;
+    /**
+     * Data to display in the table
+     */
+    readonly data: _angular_core.InputSignal<T[]>;
+    /**
+     * Track-by function for row rendering performance.
+     * Defaults to tracking by index.
+     */
+    readonly trackBy: _angular_core.InputSignal<(index: number, item: T) => unknown>;
+    /**
+     * Enable click-to-highlight feature for rows
+     */
+    readonly enableRowHighlight: _angular_core.InputSignal<boolean>;
+    /**
+     * Accessible label for the table
+     */
+    readonly tableAriaLabel: _angular_core.InputSignal<string>;
+    private _liveAnnouncer?;
+    /**
+     * Message shown when the data array is empty. Pass empty string to hide.
+     */
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    /**
+     * Current sort configuration
+     */
+    readonly sort: _angular_core.InputSignal<{
+        field: string;
+        direction: "ASC" | "DESC";
+    } | null>;
+    /**
+     * Event emitted when sort changes
+     */
+    readonly sortChange: _angular_core.OutputEmitterRef<{
+        field: string;
+        direction: "ASC" | "DESC";
+    } | null>;
+    /**
+     * Current filters
+     */
+    readonly filters: _angular_core.InputSignal<ColumnFilter[]>;
+    /**
+     * Event emitted when filters change
+     */
+    readonly filtersChange: _angular_core.OutputEmitterRef<ColumnFilter[]>;
+    /**
+     * Row dblClick event
+     */
+    readonly rowDblClick: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Internal state for selected row indices
+     */
+    readonly selectedRows: _angular_core.WritableSignal<Set<unknown>>;
+    /**
+     * Internal state for highlighted row indices
+     */
+    readonly highlightedRows: _angular_core.WritableSignal<Set<unknown>>;
+    /**
+     * Temporary filter state while editing filter menu
+     */
+    tempFilterOperator: FilterOperator | null;
+    tempFilterValue: string;
+    tempFilterValue2: string;
+    /**
+     * Whether all rows are selected
+     */
+    readonly allRowsSelected: _angular_core.Signal<boolean>;
+    /**
+     * Whether some (but not all) rows are selected
+     */
+    readonly someRowsSelected: _angular_core.Signal<boolean>;
+    /**
+     * Computed headers with sticky information
+     */
+    readonly processedHeaders: _angular_core.Signal<{
+        isStartSticky: boolean;
+        isEndSticky: boolean;
+        isLastStartSticky: boolean;
+        isFirstEndSticky: boolean;
+        startStickyPosition: number;
+        endStickyPosition: number;
+        /**
+         * Whether this column should be sticky at the start
+         * Only applies to columns at the start of the array until first false is encountered
+         */
+        stickyColumnStart?: boolean;
+        /**
+         * Whether this column should be sticky at the end
+         * First true value makes all following columns sticky
+         */
+        stickyColumnEnd?: boolean;
+        /**
+         * Display label for the column header
+         */
+        label: string;
+        /**
+         * Data type of the column (e.g., 'string', 'number', 'date', 'boolean')
+         */
+        type: string;
+        /**
+         * Property path in the data object (e.g., 'user.name', 'address.city')
+         * Format: <entityName>.<property>, can have multiple levels for nested objects
+         */
+        field: string;
+        /**
+         * Whether this column supports sorting
+         */
+        hasSort?: boolean;
+        /**
+         * Whether this column supports filtering
+         */
+        hasFilter?: boolean;
+        labels?: AdvancedDataTableLabelConfig[];
+    }[]>;
+    /**
+     * Get header classes
+     */
+    getHeaderClasses(header: ProcessedDataTableHeader): string;
+    /**
+     * Get cell classes
+     */
+    getCellClasses(header: ProcessedDataTableHeader): string;
+    /**
+     * Get header styles for sticky positioning
+     */
+    getHeaderStyles(header: ProcessedDataTableHeader): Record<string, string>;
+    /**
+     * Get cell styles for sticky positioning
+     */
+    getCellStyles(header: ProcessedDataTableHeader): Record<string, string>;
+    /**
+     * Extract value from nested object using dot notation
+     */
+    getCellValue(row: T, columnPath: string): unknown;
+    /**
+     * Format cell value based on type
+     */
+    formatCellValue(value: unknown, type: string): string;
+    /**
+     * Toggle all rows selection
+     */
+    toggleAllRows(): void;
+    /**
+     * Toggle single row selection
+     */
+    toggleRow(index: number): void;
+    /**
+     * Check if a row is selected
+     */
+    isRowSelected(index: number): boolean;
+    /**
+     * Toggle row highlight (only if enableRowHighlight is true)
+     */
+    toggleRowHighlight(index: number): void;
+    /**
+     * Check if a row is highlighted
+     */
+    isRowHighlighted(index: number): boolean;
+    /**
+     * Get ARIA sort value for a column header
+     */
+    getAriaSortValue(field: string): 'ascending' | 'descending' | 'none' | null;
+    /**
+     * Handle sort button click
+     * Cycles through: ASC → DESC → null (no sort)
+     */
+    onSortClick(field: string): void;
+    /**
+     * Get sort icon classes for a header
+     */
+    getSortIconClasses(field: string): string;
+    /**
+     * Get available filter operators for a column type
+     */
+    getFilterOperators(type: string): FilterOperatorOption[];
+    getLabelConfig(value: unknown, labels: AdvancedDataTableLabelConfig[]): AdvancedDataTableLabelConfig | null;
+    /**
+     * Initialize filter form for a field
+     * Called when menu is opened
+     */
+    initFilterForm(field: string, type: string): void;
+    /**
+     * Reset filter form
+     */
+    resetFilterForm(): void;
+    /**
+     * Apply filter for a field
+     */
+    applyFilter(field: string, type: string, menu?: FuiMenuComponent): void;
+    /**
+     * Clear filter for a field
+     */
+    clearFilter(field: string, menu?: FuiMenuComponent): void;
+    /**
+     * Parse value by column type
+     */
+    private parseValueByType;
+    /**
+     * Announce a message to screen readers via live region
+     */
+    private _announce;
+    /**
+     * Check if a field has an active filter
+     */
+    hasActiveFilter(field: string): boolean;
+    /**
+     * Get filter icon classes
+     */
+    getFilterIconClasses(field: string): string;
+    /**
+     * Check if current operator requires second input
+     */
+    requiresSecondInput(type: string): boolean;
+    /**
+     * Check if current operator requires any input
+     */
+    requiresInput(type: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiAdvancedDataTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiAdvancedDataTableComponent<any>, "fui-advanced-data-table", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "enableRowHighlight": { "alias": "enableRowHighlight"; "required": false; "isSignal": true; }; "tableAriaLabel": { "alias": "tableAriaLabel"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "filtersChange": "filtersChange"; "rowDblClick": "rowDblClick"; }, never, never, true, never>;
+}
+
+export { FilterOperator, FuiAdvancedDataTableComponent };
+export type { AdvancedDataTableConfig, AdvancedDataTableHeader, AdvancedDataTableLabelConfig, ColumnFilter, ProcessedDataTableHeader };
+//# sourceMappingURL=raintonic-formaui-components-data-table.d.ts.map

package/types/raintonic-formaui-components-data-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-data-table.d.ts","sources":["../../../lib/components/data-table/advanced-data-table.component.ts"],"mappings":";;;AAuBA;;;;AAIG;UACc,4BAA4B;;;;;AAK5C;AAED;;AAEG;UACc,uBAAuB;AACtC;;;AAGG;;AAGH;;;AAGG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;;AAGG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH,aAAS,4BAA4B;AACtC;AAED;;AAEG;AACH;;AAEG;AACG,UAAW,wBAAyB,SAAQ,uBAAuB;;;;;;;AAOxE;UAEgB,uBAAuB;AACtC;;AAEG;;AAGH;;AAEG;aACM,uBAAuB;AAEhC;;AAEG;;AAEJ;AAED;;AAEG;AACH,aAAY,cAAc;AAExB;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AAGA;AACA;AACD;AAED;;AAEG;UACc,YAAY;;cAEjB,cAAc;AACxB,uCAAmC,IAAI,sBAAsB,IAAI;AAClE;AAED;;AAEG;AACH,UAAU,oBAAoB;WACrB,cAAc;;;;AAItB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACH,cAyBa,6BAA6B,KAAK,MAAM;AACnD;;AAEG;qBACY,aAAA,CAAA,WAAA,CAAA,uBAAA;AAEf;;AAEG;mBACU,aAAA,CAAA,WAAA;AAEb;;;AAGG;sBACa,aAAA,CAAA,WAAA;AAEhB;;AAEG;iCACwB,aAAA,CAAA,WAAA;AAE3B;;AAEG;6BACoB,aAAA,CAAA,WAAA;;AAIvB;;AAEG;2BACkB,aAAA,CAAA,WAAA;AAErB;;AAEG;AACH,mBAAa,aAAA,CAAA,WAAA;;AAAqC;AAA+B;AAEjF;;AAEG;AACH,yBAAmB,aAAA,CAAA,gBAAA;;AAAsC;AAA2B;AAEpF;;AAEG;sBACa,aAAA,CAAA,WAAA,CAAA,YAAA;AAEhB;;AAEG;4BACmB,aAAA,CAAA,gBAAA,CAAA,YAAA;AAEtB;;AAEG;0BACiB,aAAA,CAAA,gBAAA;AAEpB;;AAEG;2BACkB,aAAA,CAAA,cAAA,CAAA,GAAA;AAErB;;AAEG;8BACqB,aAAA,CAAA,cAAA,CAAA,GAAA;AAExB;;AAEG;AACH,wBAAoB,cAAc;AAClC;AACA;AAEA;;AAEG;8BACqB,aAAA,CAAA,MAAA;AAKxB;;AAEG;+BACsB,aAAA,CAAA,MAAA;AAKzB;;AAEG;AACH,+BAAyB,aAAA,CAAA,MAAA;;;;;;;AAtQzB;;;AAGG;;AAGH;;;AAGG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;;AAGG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGM,iBAAA,4BAA4B;AA0RlC;AAEH;;AAEG;AACH,6BAAyB,wBAAwB;AAiBjD;;AAEG;AACH,2BAAuB,wBAAwB;AAiB/C;;AAEG;4BACqB,wBAAwB,GAAG,MAAM;AAWzD;;AAEG;0BACmB,wBAAwB,GAAG,MAAM;AAIvD;;AAEG;;AAiBH;;AAEG;;AAuBH;;AAEG;AACH;AAUA;;AAEG;AACH;AAUA;;AAEG;AACH;AAIA;;AAEG;AACH;AAcA;;AAEG;AACH;AAIA;;AAEG;;AAWH;;;AAGG;AACH;AAkBA;;AAEG;AACH;AAeA;;AAEG;AACH,sCAAkC,oBAAoB;AA2DtD,2CAAuC,4BAA4B,KAAK,4BAA4B;AAIpG;;;AAGG;;AA8BH;;AAEG;AACH;AAMA;;AAEG;AACH,oDAAgD,gBAAgB;AAkChE;;AAEG;sCAC+B,gBAAgB;AAQlD;;AAEG;AACH;AAeA;;AAEG;AACH;AAMA;;AAEG;AACH;AAIA;;AAEG;AACH;AAQA;;AAEG;AACH;AAQA;;AAEG;AACH;oDAzkBW,6BAA6B;sDAA7B,6BAA6B;AAglBzC;;;;","names":[]}