@toolbox-web/grid-angular 0.9.1 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolbox-web/grid-angular",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "Angular adapter for @toolbox-web/grid data grid component",
   "type": "module",
   "keywords": [

package/types/toolbox-web-grid-angular-features-export.d.ts

@@ -1,3 +1,115 @@
+import { Signal } from '@angular/core';
+import { ExportParams, ExportFormat } from '@toolbox-web/grid/plugins/export';
 
-export { };
+/**
+ * Export feature for @toolbox-web/grid-angular
+ *
+ * Import this module to enable the `export` input on Grid directive.
+ * Also exports `injectGridExport()` for programmatic export control.
+ *
+ * @example
+ * ```typescript
+ * import '@toolbox-web/grid-angular/features/export';
+ *
+ * <tbw-grid [export]="true" />
+ * <tbw-grid [export]="{ fileName: 'data.csv' }" />
+ * ```
+ *
+ * @example Using injectGridExport
+ * ```typescript
+ * import { injectGridExport } from '@toolbox-web/grid-angular/features/export';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private gridExport = injectGridExport();
+ *
+ *   exportData() {
+ *     this.gridExport.exportToCsv('employees.csv');
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Export methods returned from injectGridExport.
+ *
+ * Uses lazy discovery - the grid is found on first method call, not during initialization.
+ * This ensures it works with lazy-rendered tabs, conditional rendering, etc.
+ */
+interface ExportMethods {
+    /**
+     * Export grid data to CSV file.
+     * @param filename - Optional filename (defaults to 'export.csv')
+     * @param params - Optional export parameters
+     */
+    exportToCsv: (filename?: string, params?: Partial<ExportParams>) => void;
+    /**
+     * Export grid data to Excel file (XML Spreadsheet format).
+     * @param filename - Optional filename (defaults to 'export.xlsx')
+     * @param params - Optional export parameters
+     */
+    exportToExcel: (filename?: string, params?: Partial<ExportParams>) => void;
+    /**
+     * Export grid data to JSON file.
+     * @param filename - Optional filename (defaults to 'export.json')
+     * @param params - Optional export parameters
+     */
+    exportToJson: (filename?: string, params?: Partial<ExportParams>) => void;
+    /**
+     * Check if an export is currently in progress.
+     */
+    isExporting: () => boolean;
+    /**
+     * Get information about the last export.
+     */
+    getLastExport: () => {
+        format: ExportFormat;
+        timestamp: Date;
+    } | null;
+    /**
+     * Signal indicating if grid is ready.
+     * The grid is discovered lazily, so this updates when first method call succeeds.
+     */
+    isReady: Signal<boolean>;
+}
+/**
+ * Angular inject function for programmatic export control.
+ *
+ * Uses **lazy grid discovery** - the grid element is found when methods are called,
+ * not during initialization. This ensures it works reliably with:
+ * - Lazy-rendered tabs
+ * - Conditional rendering (*ngIf)
+ * - Dynamic component loading
+ *
+ * @example
+ * ```typescript
+ * import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+ * import { Grid } from '@toolbox-web/grid-angular';
+ * import '@toolbox-web/grid-angular/features/export';
+ * import { injectGridExport } from '@toolbox-web/grid-angular/features/export';
+ *
+ * @Component({
+ *   selector: 'app-my-grid',
+ *   imports: [Grid],
+ *   schemas: [CUSTOM_ELEMENTS_SCHEMA],
+ *   template: `
+ *     <button (click)="handleExport()">Export CSV</button>
+ *     <tbw-grid [rows]="rows" [export]="true"></tbw-grid>
+ *   `
+ * })
+ * export class MyGridComponent {
+ *   gridExport = injectGridExport();
+ *
+ *   handleExport() {
+ *     this.gridExport.exportToCsv('employees.csv');
+ *   }
+ * }
+ * ```
+ */
+declare function injectGridExport(): ExportMethods;
+
+export { injectGridExport };
+export type { ExportMethods };
 //# sourceMappingURL=toolbox-web-grid-angular-features-export.d.ts.map

package/types/toolbox-web-grid-angular-features-export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolbox-web-grid-angular-features-export.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"toolbox-web-grid-angular-features-export.d.ts","sources":["../../../../libs/grid-angular/features/export/src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;;AAcH;;;;;AAKG;;AAED;;;;AAIG;AACH,8CAAA,OAAA,CAAA,YAAA;AAEA;;;;AAIG;AACH,gDAAA,OAAA,CAAA,YAAA;AAEA;;;;AAIG;AACH,+CAAA,OAAA,CAAA,YAAA;AAEA;;AAEG;;AAGH;;AAEG;AACH;;;AAA8D;AAE9D;;;AAGG;AACH,aAAA,MAAA;AACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACH,iBAAA,gBAAA,IAAA,aAAA;;;;"}

package/types/toolbox-web-grid-angular-features-filtering.d.ts

@@ -1,3 +1,122 @@
+import { Signal } from '@angular/core';
+import { FilterModel } from '@toolbox-web/grid/plugins/filtering';
 
-export { };
+/**
+ * Filtering feature for @toolbox-web/grid-angular
+ *
+ * Import this module to enable the `filtering` input on Grid directive.
+ * Also exports `injectGridFiltering()` for programmatic filter control.
+ *
+ * @example
+ * ```typescript
+ * import '@toolbox-web/grid-angular/features/filtering';
+ *
+ * <tbw-grid [filtering]="true" />
+ * <tbw-grid [filtering]="{ debounceMs: 200 }" />
+ * ```
+ *
+ * @example Using injectGridFiltering
+ * ```typescript
+ * import { injectGridFiltering } from '@toolbox-web/grid-angular/features/filtering';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private filtering = injectGridFiltering();
+ *
+ *   filterByStatus(status: string) {
+ *     this.filtering.setFilter('status', { operator: 'equals', value: status });
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Filtering methods returned from injectGridFiltering.
+ *
+ * Uses lazy discovery - the grid is found on first method call, not during initialization.
+ */
+interface FilteringMethods {
+    /**
+     * Set a filter on a specific field.
+     * @param field - The field name to filter
+     * @param filter - Filter configuration, or null to remove
+     */
+    setFilter: (field: string, filter: Omit<FilterModel, 'field'> | null) => void;
+    /**
+     * Get the current filter for a field.
+     */
+    getFilter: (field: string) => FilterModel | undefined;
+    /**
+     * Get all active filters.
+     */
+    getFilters: () => FilterModel[];
+    /**
+     * Set all filters at once (replaces existing).
+     */
+    setFilterModel: (filters: FilterModel[]) => void;
+    /**
+     * Clear all active filters.
+     */
+    clearAllFilters: () => void;
+    /**
+     * Clear filter for a specific field.
+     */
+    clearFieldFilter: (field: string) => void;
+    /**
+     * Check if a field has an active filter.
+     */
+    isFieldFiltered: (field: string) => boolean;
+    /**
+     * Get the count of rows after filtering.
+     */
+    getFilteredRowCount: () => number;
+    /**
+     * Get unique values for a field (for building filter dropdowns).
+     */
+    getUniqueValues: (field: string) => unknown[];
+    /**
+     * Signal indicating if grid is ready.
+     */
+    isReady: Signal<boolean>;
+}
+/**
+ * Angular inject function for programmatic filter control.
+ *
+ * Uses **lazy grid discovery** - the grid element is found when methods are called,
+ * not during initialization.
+ *
+ * @example
+ * ```typescript
+ * import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+ * import { Grid } from '@toolbox-web/grid-angular';
+ * import '@toolbox-web/grid-angular/features/filtering';
+ * import { injectGridFiltering } from '@toolbox-web/grid-angular/features/filtering';
+ *
+ * @Component({
+ *   selector: 'app-my-grid',
+ *   imports: [Grid],
+ *   schemas: [CUSTOM_ELEMENTS_SCHEMA],
+ *   template: `
+ *     <input (input)="applyFilter($event)" placeholder="Filter by name..." />
+ *     <span>{{ filtering.getFilteredRowCount() }} results</span>
+ *     <button (click)="filtering.clearAllFilters()">Clear</button>
+ *     <tbw-grid [rows]="rows" [filtering]="true"></tbw-grid>
+ *   `
+ * })
+ * export class MyGridComponent {
+ *   filtering = injectGridFiltering();
+ *
+ *   applyFilter(event: Event) {
+ *     const value = (event.target as HTMLInputElement).value;
+ *     this.filtering.setFilter('name', value ? { operator: 'contains', value } : null);
+ *   }
+ * }
+ * ```
+ */
+declare function injectGridFiltering(): FilteringMethods;
+
+export { injectGridFiltering };
+export type { FilteringMethods };
 //# sourceMappingURL=toolbox-web-grid-angular-features-filtering.d.ts.map

package/types/toolbox-web-grid-angular-features-filtering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolbox-web-grid-angular-features-filtering.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"toolbox-web-grid-angular-features-filtering.d.ts","sources":["../../../../libs/grid-angular/features/filtering/src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;;AAcH;;;;AAIG;;AAED;;;;AAIG;AACH,uCAAA,IAAA,CAAA,WAAA;AAEA;;AAEG;;AAGH;;AAEG;AACH,sBAAA,WAAA;AAEA;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;AACH,aAAA,MAAA;AACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACH,iBAAA,mBAAA,IAAA,gBAAA;;;;"}

package/types/toolbox-web-grid-angular-features-print.d.ts

@@ -1,3 +1,93 @@
+import { Signal } from '@angular/core';
+import { PrintParams } from '@toolbox-web/grid/plugins/print';
 
-export { };
+/**
+ * Print feature for @toolbox-web/grid-angular
+ *
+ * Import this module to enable the `print` input on Grid directive.
+ * Also exports `injectGridPrint()` for programmatic print control.
+ *
+ * @example
+ * ```typescript
+ * import '@toolbox-web/grid-angular/features/print';
+ *
+ * <tbw-grid [print]="true" />
+ * ```
+ *
+ * @example Using injectGridPrint
+ * ```typescript
+ * import { injectGridPrint } from '@toolbox-web/grid-angular/features/print';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private gridPrint = injectGridPrint();
+ *
+ *   printReport() {
+ *     this.gridPrint.print({ title: 'My Report' });
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Print methods returned from injectGridPrint.
+ *
+ * Uses lazy discovery - the grid is found on first method call, not during initialization.
+ */
+interface PrintMethods {
+    /**
+     * Print the grid.
+     * Opens browser print dialog after preparing the grid for printing.
+     * @param params - Optional print parameters
+     */
+    print: (params?: PrintParams) => Promise<void>;
+    /**
+     * Check if a print operation is currently in progress.
+     */
+    isPrinting: () => boolean;
+    /**
+     * Signal indicating if grid is ready.
+     */
+    isReady: Signal<boolean>;
+}
+/**
+ * Angular inject function for programmatic print control.
+ *
+ * Uses **lazy grid discovery** - the grid element is found when methods are called,
+ * not during initialization.
+ *
+ * @example
+ * ```typescript
+ * import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+ * import { Grid } from '@toolbox-web/grid-angular';
+ * import '@toolbox-web/grid-angular/features/print';
+ * import { injectGridPrint } from '@toolbox-web/grid-angular/features/print';
+ *
+ * @Component({
+ *   selector: 'app-my-grid',
+ *   imports: [Grid],
+ *   schemas: [CUSTOM_ELEMENTS_SCHEMA],
+ *   template: `
+ *     <button (click)="handlePrint()" [disabled]="gridPrint.isPrinting()">
+ *       {{ gridPrint.isPrinting() ? 'Printing...' : 'Print' }}
+ *     </button>
+ *     <tbw-grid [rows]="rows" [print]="true"></tbw-grid>
+ *   `
+ * })
+ * export class MyGridComponent {
+ *   gridPrint = injectGridPrint();
+ *
+ *   async handlePrint() {
+ *     await this.gridPrint.print({ title: 'Employee Report', isolate: true });
+ *     console.log('Print dialog closed');
+ *   }
+ * }
+ * ```
+ */
+declare function injectGridPrint(): PrintMethods;
+
+export { injectGridPrint };
+export type { PrintMethods };
 //# sourceMappingURL=toolbox-web-grid-angular-features-print.d.ts.map

package/types/toolbox-web-grid-angular-features-print.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolbox-web-grid-angular-features-print.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"toolbox-web-grid-angular-features-print.d.ts","sources":["../../../../libs/grid-angular/features/print/src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;;AAcH;;;;AAIG;;AAED;;;;AAIG;;AAGH;;AAEG;;AAGH;;AAEG;AACH,aAAA,MAAA;AACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACH,iBAAA,eAAA,IAAA,YAAA;;;;"}

package/types/toolbox-web-grid-angular-features-selection.d.ts

@@ -1,3 +1,116 @@
+import { Signal } from '@angular/core';
+import { SelectionResult, CellRange } from '@toolbox-web/grid/plugins/selection';
 
-export { };
+/**
+ * Selection feature for @toolbox-web/grid-angular
+ *
+ * Import this module to enable the `selection` input on Grid directive.
+ * Also exports `injectGridSelection()` for programmatic selection control.
+ *
+ * @example
+ * ```typescript
+ * import '@toolbox-web/grid-angular/features/selection';
+ *
+ * <tbw-grid [selection]="'range'" />
+ * ```
+ *
+ * @example Using injectGridSelection
+ * ```typescript
+ * import { injectGridSelection } from '@toolbox-web/grid-angular/features/selection';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private selection = injectGridSelection<Employee>();
+ *
+ *   selectAll() {
+ *     this.selection.selectAll();
+ *   }
+ *
+ *   getSelected() {
+ *     return this.selection.getSelection();
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Selection methods returned from injectGridSelection.
+ *
+ * Uses lazy discovery - the grid is found on first method call, not during initialization.
+ * This ensures it works with lazy-rendered tabs, conditional rendering, etc.
+ */
+interface SelectionMethods {
+    /**
+     * Select all rows (row mode) or all cells (range mode).
+     */
+    selectAll: () => void;
+    /**
+     * Clear all selection.
+     */
+    clearSelection: () => void;
+    /**
+     * Get the current selection state.
+     * Use this to derive selected rows, indices, etc.
+     */
+    getSelection: () => SelectionResult | null;
+    /**
+     * Check if a specific cell is selected.
+     */
+    isCellSelected: (row: number, col: number) => boolean;
+    /**
+     * Set selection ranges programmatically.
+     */
+    setRanges: (ranges: CellRange[]) => void;
+    /**
+     * Signal indicating if grid is ready.
+     * The grid is discovered lazily, so this updates when first method call succeeds.
+     */
+    isReady: Signal<boolean>;
+}
+/**
+ * Angular inject function for programmatic selection control.
+ *
+ * Uses **lazy grid discovery** - the grid element is found when methods are called,
+ * not during initialization. This ensures it works reliably with:
+ * - Lazy-rendered tabs
+ * - Conditional rendering (*ngIf)
+ * - Dynamic component loading
+ *
+ * @example
+ * ```typescript
+ * import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+ * import { Grid } from '@toolbox-web/grid-angular';
+ * import '@toolbox-web/grid-angular/features/selection';
+ * import { injectGridSelection } from '@toolbox-web/grid-angular/features/selection';
+ *
+ * @Component({
+ *   selector: 'app-my-grid',
+ *   imports: [Grid],
+ *   schemas: [CUSTOM_ELEMENTS_SCHEMA],
+ *   template: `
+ *     <button (click)="handleSelectAll()">Select All</button>
+ *     <tbw-grid [rows]="rows" [selection]="'range'"></tbw-grid>
+ *   `
+ * })
+ * export class MyGridComponent {
+ *   selection = injectGridSelection();
+ *
+ *   handleSelectAll() {
+ *     this.selection.selectAll();
+ *   }
+ *
+ *   getSelectedRows() {
+ *     const selection = this.selection.getSelection();
+ *     if (!selection) return [];
+ *     // Derive rows from selection.ranges as needed
+ *   }
+ * }
+ * ```
+ */
+declare function injectGridSelection<TRow = unknown>(): SelectionMethods;
+
+export { injectGridSelection };
+export type { SelectionMethods };
 //# sourceMappingURL=toolbox-web-grid-angular-features-selection.d.ts.map

package/types/toolbox-web-grid-angular-features-selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolbox-web-grid-angular-features-selection.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"toolbox-web-grid-angular-features-selection.d.ts","sources":["../../../../libs/grid-angular/features/selection/src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;;AAgBH;;;;;AAKG;;AAED;;AAEG;;AAGH;;AAEG;;AAGH;;;AAGG;AACH,wBAAA,eAAA;AAEA;;AAEG;;AAGH;;AAEG;;AAGH;;;AAGG;AACH,aAAA,MAAA;AACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACH,iBAAA,mBAAA,oBAAA,gBAAA;;;;"}

package/types/toolbox-web-grid-angular-features-undo-redo.d.ts

@@ -1,3 +1,109 @@
+import { Signal } from '@angular/core';
+import { EditAction } from '@toolbox-web/grid/plugins/undo-redo';
 
-export { };
+/**
+ * Undo/Redo feature for @toolbox-web/grid-angular
+ *
+ * Import this module to enable the `undoRedo` input on Grid directive.
+ * Also exports `injectGridUndoRedo()` for programmatic undo/redo control.
+ * Requires editing feature to be enabled.
+ *
+ * @example
+ * ```typescript
+ * import '@toolbox-web/grid-angular/features/editing';
+ * import '@toolbox-web/grid-angular/features/undo-redo';
+ *
+ * <tbw-grid [editing]="'dblclick'" [undoRedo]="true" />
+ * ```
+ *
+ * @example Using injectGridUndoRedo
+ * ```typescript
+ * import { injectGridUndoRedo } from '@toolbox-web/grid-angular/features/undo-redo';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private undoRedo = injectGridUndoRedo();
+ *
+ *   undo() { this.undoRedo.undo(); }
+ *   redo() { this.undoRedo.redo(); }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Undo/Redo methods returned from injectGridUndoRedo.
+ *
+ * Uses lazy discovery - the grid is found on first method call, not during initialization.
+ */
+interface UndoRedoMethods {
+    /**
+     * Undo the last edit action.
+     * @returns The undone action, or null if nothing to undo
+     */
+    undo: () => EditAction | null;
+    /**
+     * Redo the last undone action.
+     * @returns The redone action, or null if nothing to redo
+     */
+    redo: () => EditAction | null;
+    /**
+     * Check if there are any actions that can be undone.
+     */
+    canUndo: () => boolean;
+    /**
+     * Check if there are any actions that can be redone.
+     */
+    canRedo: () => boolean;
+    /**
+     * Clear all undo/redo history.
+     */
+    clearHistory: () => void;
+    /**
+     * Get a copy of the current undo stack.
+     */
+    getUndoStack: () => EditAction[];
+    /**
+     * Get a copy of the current redo stack.
+     */
+    getRedoStack: () => EditAction[];
+    /**
+     * Signal indicating if grid is ready.
+     */
+    isReady: Signal<boolean>;
+}
+/**
+ * Angular inject function for programmatic undo/redo control.
+ *
+ * Uses **lazy grid discovery** - the grid element is found when methods are called,
+ * not during initialization.
+ *
+ * @example
+ * ```typescript
+ * import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+ * import { Grid } from '@toolbox-web/grid-angular';
+ * import '@toolbox-web/grid-angular/features/editing';
+ * import '@toolbox-web/grid-angular/features/undo-redo';
+ * import { injectGridUndoRedo } from '@toolbox-web/grid-angular/features/undo-redo';
+ *
+ * @Component({
+ *   selector: 'app-my-grid',
+ *   imports: [Grid],
+ *   schemas: [CUSTOM_ELEMENTS_SCHEMA],
+ *   template: `
+ *     <button (click)="undoRedo.undo()" [disabled]="!undoRedo.canUndo()">Undo</button>
+ *     <button (click)="undoRedo.redo()" [disabled]="!undoRedo.canRedo()">Redo</button>
+ *     <tbw-grid [rows]="rows" [editing]="'dblclick'" [undoRedo]="true"></tbw-grid>
+ *   `
+ * })
+ * export class MyGridComponent {
+ *   undoRedo = injectGridUndoRedo();
+ * }
+ * ```
+ */
+declare function injectGridUndoRedo(): UndoRedoMethods;
+
+export { injectGridUndoRedo };
+export type { UndoRedoMethods };
 //# sourceMappingURL=toolbox-web-grid-angular-features-undo-redo.d.ts.map

package/types/toolbox-web-grid-angular-features-undo-redo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolbox-web-grid-angular-features-undo-redo.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"toolbox-web-grid-angular-features-undo-redo.d.ts","sources":["../../../../libs/grid-angular/features/undo-redo/src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;;AAcH;;;;AAIG;;AAED;;;AAGG;AACH,gBAAA,UAAA;AAEA;;;AAGG;AACH,gBAAA,UAAA;AAEA;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;AACH,wBAAA,UAAA;AAEA;;AAEG;AACH,wBAAA,UAAA;AAEA;;AAEG;AACH,aAAA,MAAA;AACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACH,iBAAA,kBAAA,IAAA,eAAA;;;;"}