@guiexpert/table 1.1.90 → 1.1.91

package/lib/table/data/tablemodel/areamodel/area-model.d.ts

@@ -1,96 +1,59 @@
-import { AreaModelIf } from './area-model.if';
-import { AreaIdent } from '../area-ident.type';
-import { CheckboxModelIf } from '../../../checkbox/checkbox-model.if';
-import { SortItem } from '../../common/sort-item';
-import { FilterFunction } from '../../common/filter-function';
-import { CellRendererIf } from '../../../renderer/cell-render.if';
-import { CheckedType } from '../../common/checked-type';
+import { AreaModelIf } from './area-model.if.js';
+import { AreaIdent } from '../area-ident.type.js';
+import { CheckboxModelIf } from '../../../checkbox/checkbox-model.if.js';
+import { SortItem } from '../../common/sort-item.js';
+import { FilterFunction } from '../../common/filter-function.js';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { CheckedType } from '../../common/checked-type.js';
 
 /**
- * @class AreaModel
- * @implements {AreaModelIf}
- * @description
- * The AreaModel class is a base implementation of the AreaModelIf interface.
- * It represents a model for a specific area of a table (header, body, or footer)
- * and provides methods for accessing and manipulating data within that area.
+ * Base class for area models of your own – every method of {@link AreaModelIf} has a sensible default,
+ * override only what you need (at least {@link getRowCount}, {@link getValueAt} and {@link getRowHeight}).
  *
- * In the GuiExpert Table library, a table is divided into three main areas:
- * - Header: Contains column titles and optional filter/sort controls
- * - Body: Contains the main data of the table
- * - Footer: Contains summary information or additional controls
- *
- * Each of these areas can be further divided into three sections:
- * - West: Fixed columns on the left side
- * - Center: Scrollable columns in the middle
- * - East: Fixed columns on the right side
- *
- * <pre>
- *  +----------------+-------------------+--------------+
- *  |  header/west   |  header/center    | header/east  |
- *  +----------------+-------------------+--------------+
- *  |  body/west     |  body/center      | body/east    |
- *  +----------------+-------------------+--------------+
- *  |  footer/west   |  footer/center    | footer/east  |
- *  +----------------+-------------------+--------------+
- * </pre>
- *
- * This base AreaModel class provides default implementations for all methods
- * required by the AreaModelIf interface. Most methods return default values
- * or do nothing, making this class suitable as a starting point for creating
- * more specialized area models.
+ * A table consists of three area models – header, body and footer ({@link AreaIdent}) – and asks them only for
+ * the cells that are visible. That makes models possible that compute values on demand (millions of rows,
+ * server data) or summarise other models (footer totals).
  *
  * @example
- * // Creating a basic area model for the header
- * const headerModel = new AreaModel();
- * headerModel.areaIdent = "header";
- *
- * @example
- * // Extending AreaModel to create a custom implementation
- * class CustomAreaModel extends AreaModel {
- *   private data: any[][];
- *
- *   constructor(data: any[][]) {
+ * // a body with two million rows – no array behind it
+ * class TwoMillionRows extends AreaModel {
+ *   constructor() {
  *     super();
- *     this.data = data;
+ *     this.areaIdent = "body";
  *   }
- *
- *   getRowCount(): number {
- *     return this.data.length;
- *   }
- *
- *   getValueAt(rowIndex: number, columnIndex: number): any {
- *     if (rowIndex < 0 || rowIndex >= this.data.length) return undefined;
- *     const row = this.data[rowIndex];
- *     if (columnIndex < 0 || columnIndex >= row.length) return undefined;
- *     return row[columnIndex];
+ *   override getRowCount(): number { return 2_000_000; }
+ *   override getRowHeight(_rowIndex: number): number { return 34; }
+ *   override getConstantRowHeight(): number { return 34; }   // all rows equally high → O(1) scrolling
+ *   override getValueAt(row: number, col: number): any {
+ *     return col === 0 ? row + 1 : `cell ${row}/${col}`;
  *   }
- *
- *   // Override other methods as needed...
  * }
+ * const tableModel = TableFactory.createTableModel({
+ *   bodyAreaModel: new TwoMillionRows(),
+ *   columnDefs: [new ColumnDef("id", "ID", px100, allRight), new ColumnDef("text", "Text", px200)]
+ * });
  *
  * @example
- * // Using AreaModel with a TableModel
- * import { TableFactory, TableModelIf } from "@guiexpert/table";
- *
- * // Create a table model with custom area models
- * const tableModel: TableModelIf = TableFactory.createTableModel();
- *
- * // Set custom area models
- * const headerModel = new CustomAreaModel([["ID", "Name", "Age"]]);
- * headerModel.areaIdent = "header";
- * tableModel.setAreaModel("header", headerModel);
+ * // a footer that sums the rows the body currently shows (after filter and sorting)
+ * class TotalsFooter extends AreaModel {
+ *   constructor(private readonly getBody: () => AreaModelObjectArray<Order>) {
+ *     super();
+ *     this.areaIdent = "footer";
+ *   }
+ *   override getRowCount(): number { return 1; }
+ *   override getRowHeight(_rowIndex: number): number { return 34; }
+ *   override getValueAt(_row: number, col: number): any {
+ *     const rows = this.getBody().getFilteredRows();
+ *     return col === 0 ? `${rows.length} orders` : col === 5 ? rows.reduce((s, o) => s + o.total, 0) : "";
+ *   }
+ * }
  *
- * const bodyModel = new CustomAreaModel([
- *   [1, "John", 30],
- *   [2, "Jane", 25],
- *   [3, "Bob", 40]
- * ]);
- * bodyModel.areaIdent = "body";
- * tableModel.setAreaModel("body", bodyModel);
+ * @see {@link AreaModelObjectArray} (objects), {@link AreaModelArrayOfArrays} (rows of values), {@link AreaModelTree} (trees)
+ * @see Training: [The TableModel: three times three areas](https://gui.expert/training/table-model-areas/),
+ *   [Own AreaModel: two million rows](https://gui.expert/training/custom-area-model/),
+ *   [Footer totals](https://gui.expert/training/footer-totals/)
  *
- * @see {@link AreaModelIf} - The interface that this class implements
- * @see {@link AbstractAreaModel} - An abstract implementation with common functionality
- * @see {@link AreaModelObjectArray} - An implementation for object array data
+ * @category Area models
  */
 export declare class AreaModel implements AreaModelIf {
     /**
@@ -141,31 +104,29 @@ export declare class AreaModel implements AreaModelIf {
     changeColumnOrder(_sourceColumnIndex: number, _targetColumnIndex: number): void;
     /**
      * Sorts the rows in this area based on the provided sort items.
-     * This method is called when the user clicks on a sortable column header.
+     * Called when the user double-clicks a sortable column header (and by {@link TableApi.sortByColumn}).
      * The base implementation returns false (no sorting performed) and should be
-     * overridden by subclasses that support sorting.
+     * overridden by subclasses that hold their rows themselves.
      *
      * @param {SortItem[]} _sortItems - An array of sort items, each containing a column index and sort direction
      * @returns {boolean} True if sorting was performed, false otherwise
      *
      * @example
-     * // Override in a subclass to implement sorting
-     * doSort(sortItems: SortItem[]): boolean {
-     *   if (!sortItems.length) return false;
+     * class SortableRows extends AreaModel {
+     *   constructor(private readonly rows: any[][]) {
+     *     super();
+     *     this.areaIdent = "body";
+     *   }
+     *   override getRowCount(): number { return this.rows.length; }
+     *   override getValueAt(row: number, col: number): any { return this.rows[row][col]; }
      *
-     *   // Apply sorting to the rows
-     *   this.rows.sort((a, b) => {
+     *   override doSort(sortItems: SortItem[]): boolean {
+     *     if (!sortItems.length) return false;
      *     const { columnIndex, sortState } = sortItems[0];
-     *     const valueA = this.getValueAt(this.rows.indexOf(a), columnIndex);
-     *     const valueB = this.getValueAt(this.rows.indexOf(b), columnIndex);
-     *
-     *     const direction = sortState === 'asc' ? 1 : -1;
-     *     if (valueA < valueB) return -1 * direction;
-     *     if (valueA > valueB) return 1 * direction;
-     *     return 0;
-     *   });
-     *
-     *   return true;
+     *     const direction = sortState === "asc" ? 1 : -1;
+     *     this.rows.sort((a, b) => (a[columnIndex] < b[columnIndex] ? -1 : a[columnIndex] > b[columnIndex] ? 1 : 0) * direction);
+     *     return true;
+     *   }
      * }
      */
     doSort(_sortItems: SortItem[]): boolean;
@@ -641,19 +602,20 @@ export declare class AreaModel implements AreaModelIf {
     isRowChecked(_rowIndex: number): CheckedType | undefined;
     /**
      * Determines whether the cell at the specified row and column indices is selectable.
-     * If true, the user can select the cell.
-     * The base implementation returns false (not selectable) and should be overridden by
-     * subclasses that support cell selection.
+     * The table draws the selection (of the {@link SelectionModel}) only on selectable body cells.
+     *
+     * Default: `true` – all cells are selectable, like in all built-in area models
+     * (up to 1.1.90 the default of `AreaModel` was `false`: a selection on an own model was not drawn).
+     * Override it to exclude cells, e.g. a column of row numbers.
      *
      * @param {number} _rowIndex - The index of the row
      * @param {number} _columnIndex - The index of the column
      * @returns {boolean} True if the cell is selectable, false otherwise
      *
      * @example
-     * // Override in a subclass to implement cell selectability
-     * isSelectable(rowIndex: number, columnIndex: number): boolean {
-     *   // All cells in the body are selectable
-     *   return this.areaIdent === 'body';
+     * // Override in a subclass: the first column (row numbers) never shows a selection
+     * override isSelectable(_rowIndex: number, columnIndex: number): boolean {
+     *   return columnIndex > 0;
      * }
      */
     isSelectable(_rowIndex: number, _columnIndex: number): boolean;

package/lib/table/data/tablemodel/areamodel/area-model.if.d.ts

@@ -1,9 +1,9 @@
-import { CellRendererIf } from '../../../renderer/cell-render.if';
-import { CheckedType } from '../../common/checked-type';
-import { CheckboxModelIf } from '../../../checkbox/checkbox-model.if';
-import { FilterFunction } from '../../common/filter-function';
-import { SortItem } from '../../common/sort-item';
-import { AreaIdent } from '../area-ident.type';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { CheckedType } from '../../common/checked-type.js';
+import { CheckboxModelIf } from '../../../checkbox/checkbox-model.if.js';
+import { FilterFunction } from '../../common/filter-function.js';
+import { SortItem } from '../../common/sort-item.js';
+import { AreaIdent } from '../area-ident.type.js';
 
 /**
  * @interface AreaModelIf
@@ -57,7 +57,7 @@ import { AreaIdent } from '../area-ident.type';
  *   [2, "Jane", 25],
  *   [3, "Bob", 40]
  * ];
- * const footerData = [["", "Average", 31.67]];
+ * const footerData = [["", "Average", "31.67"]];
  *
  * // Create the table model with all three areas
  * const tableModel: TableModelIf = TableFactory.createTableModel({
@@ -88,9 +88,9 @@ import { AreaIdent } from '../area-ident.type';
  *
  * // Define column definitions
  * const columnDefs: ColumnDefIf[] = [
- *   { property: "id", headerLabel: "ID", width: 80 },
- *   { property: "name", headerLabel: "Name", width: 150 },
- *   { property: "age", headerLabel: "Age", width: 80 }
+ *   new ColumnDef('id', 'ID', new Size(80, 'px')),
+ *   new ColumnDef('name', 'Name', new Size(150, 'px')),
+ *   new ColumnDef('age', 'Age', new Size(80, 'px'))
  * ];
  *
  * // Create the table model
@@ -109,35 +109,36 @@ import { AreaIdent } from '../area-ident.type';
  * // Example of implementing a custom AreaModelIf
  * import { AreaModelIf, AreaIdent, CellRendererIf } from "@guiexpert/table";
  *
- * class CustomAreaModel implements AreaModelIf {
+ * class CustomAreaModel extends AreaModel {
  *   constructor(
- *     public areaIdent: AreaIdent,
- *     private data: any[][],
- *     private defaultRowHeight: number = 30
- *   ) {}
+ *     areaIdent: AreaIdent,
+ *     private readonly data: any[][],
+ *     private readonly rowHeight: number = 30
+ *   ) {
+ *     super();
+ *     this.areaIdent = areaIdent;
+ *   }
  *
- *   getRowCount(): number {
+ *   override getRowCount(): number {
  *     return this.data.length;
  *   }
  *
- *   getValueAt(rowIndex: number, columnIndex: number): any {
- *     if (rowIndex < 0 || rowIndex >= this.data.length) return undefined;
- *     const row = this.data[rowIndex];
- *     if (columnIndex < 0 || columnIndex >= row.length) return undefined;
- *     return row[columnIndex];
+ *   override getValueAt(rowIndex: number, columnIndex: number): any {
+ *     return this.data[rowIndex]?.[columnIndex];
  *   }
  *
- *   getRowHeight(rowIndex: number): number {
- *     return this.defaultRowHeight;
+ *   override getRowHeight(_rowIndex: number): number {
+ *     return this.rowHeight;
  *   }
- *
- *   // Implement other required methods...
+ *   // AreaModel has defaults for all other methods
  * }
  *
  * @see {@link TableModelIf} - The parent interface that contains area models
  * @see {@link AreaModel} - A base implementation of this interface
  * @see {@link AbstractAreaModel} - An abstract implementation with common functionality
  * @see {@link AreaModelObjectArray} - An implementation for object array data
+ *
+ * @category Area models
  */
 export interface AreaModelIf {
     /**
@@ -148,7 +149,8 @@ export interface AreaModelIf {
      *
      * @example
      * // Creating an area model for the header
-     * const headerModel = new AreaModel("header");
+     * const headerModel = new AreaModel();
+     * headerModel.areaIdent = "header";
      *
      * @example
      * // Checking which area a model represents
@@ -167,7 +169,8 @@ export interface AreaModelIf {
      * // Creating a checkbox model for row selection
      * import { CheckboxModel } from "@guiexpert/table";
      *
-     * const bodyModel = new AreaModel("body");
+     * const bodyModel = new AreaModel();
+     * bodyModel.areaIdent = "body";
      * bodyModel.rowSelectionModel = new CheckboxModel();
      *
      * // Later, check if a row is selected
@@ -673,7 +676,8 @@ export interface AreaModelIf {
     isEditable(rowIndex: number, columnIndex: number): boolean;
     /**
      * Determines whether the cell at the specified row and column indices is selectable.
-     * If true, the user can select the cell.
+     * If true, the user can select the cell: the table draws the selection only on selectable body cells.
+     * All built-in models and {@link AreaModel} return `true` (except the hidden and cover-grid models).
      *
      * @param {number} rowIndex - The index of the row
      * @param {number} columnIndex - The index of the column
@@ -733,9 +737,9 @@ export interface AreaModelIf {
      * @example
      * // Check if a row is checked
      * const checkedState = bodyAreaModel.isRowChecked(1);
-     * if (checkedState === true) {
+     * if (checkedState === "full") {
      *   console.log('This row is checked');
-     * } else if (checkedState === 'indeterminate') {
+     * } else if (checkedState === "semi") {
      *   console.log('This row is partially checked');
      * }
      *
@@ -836,27 +840,29 @@ export interface AreaModelIf {
      * ]);
      *
      * @example
-     * // Implementation example
-     * doSort(sortItems: SortItem[]): boolean {
-     *   if (!sortItems.length) return false;
-     *
-     *   // Apply sorting to the rows
-     *   for (const sortItem of sortItems) {
-     *     const { columnIndex, sortState } = sortItem;
-     *     const property = this.columnDefs[columnIndex].property;
-     *     const direction = sortState === 'asc' ? 1 : -1;
-     *
-     *     this.rows.sort((a, b) => {
-     *       const valueA = a[property];
-     *       const valueB = b[property];
-     *
-     *       if (valueA < valueB) return -1 * direction;
-     *       if (valueA > valueB) return 1 * direction;
-     *       return 0;
-     *     });
-     *   }
+     * // Implementation example: a body model that sorts its own rows
+     * class MyBodyModel extends AreaModelObjectArray<any> {
+     *   override doSort(sortItems: SortItem[]): boolean {
+     *     if (!sortItems.length) return false;
      *
-     *   return true;
+     *     // Apply sorting to the rows
+     *     for (const sortItem of sortItems) {
+     *       const { columnIndex, sortState } = sortItem;
+     *       const property = this.columnDefs[columnIndex].property;
+     *       const direction = sortState === 'asc' ? 1 : -1;
+     *
+     *       this.rows.sort((a, b) => {
+     *         const valueA = a[property];
+     *         const valueB = b[property];
+     *
+     *         if (valueA < valueB) return -1 * direction;
+     *         if (valueA > valueB) return 1 * direction;
+     *         return 0;
+     *       });
+     *     }
+     *
+     *     return true;
+     *   }
      * }
      */
     doSort(sortItems: SortItem[]): boolean;

package/lib/table/data/tablemodel/areamodel/async-area-model-object-array.d.ts

@@ -1,8 +1,8 @@
-import { AbstractAreaModel } from './abstract-area-model';
-import { ColumnDefIf } from '../column/column-def.if';
-import { FilterFunction } from '../../common/filter-function';
-import { SorterService } from '../../../service/sorter.service';
-import { SortItem } from '../../common/sort-item';
+import { AbstractAreaModel } from './abstract-area-model.js';
+import { ColumnDefIf } from '../column/column-def.if.js';
+import { FilterFunction } from '../../common/filter-function.js';
+import { SorterService } from '../../../service/sorter.service.js';
+import { SortItem } from '../../common/sort-item.js';
 
 export declare class AsyncBodyAreaModelObjectArray<T> extends AbstractAreaModel<T> {
     protected readonly maxRowCount: number;

package/lib/table/data/tablemodel/areamodel/col-and-rowspan-model.d.ts

@@ -1,16 +1,27 @@
-import { CellRange } from '../../common/cell-range';
-import { AreaModelIf } from './area-model.if';
-import { TableModelIf } from '../table-model.if';
+import { CellRange } from '../../common/cell-range.js';
+import { AreaModelIf } from './area-model.if.js';
+import { TableModelIf } from '../table-model.if.js';
 
 /**
  * Represents a model for handling colspan and rowspan in a table.
+ *
+ * @category Area models
  */
 export declare class ColAndRowspanModel {
     protected tableModel: TableModelIf;
     protected areaModel: AreaModelIf;
     protected colAndRowspanRanges: CellRange[] | undefined;
     constructor(tableModel: TableModelIf, areaModel: AreaModelIf);
+    /** Row count of the area model at the last {@link init} (−1: not initialized yet). */
+    protected rowCountAtInit: number;
     init(): void;
+    /**
+     * Builds the ranges again if the row count of the area model changed since the last {@link init} – e.g. after
+     * `setRows()` or a filter (the old ranges could point to rows that no longer exist). Cheap otherwise.
+     *
+     * @returns {boolean} true if the ranges were rebuilt
+     */
+    initIfRowCountChanged(): boolean;
     getRanges(): CellRange[];
     isInRange(rowIndex: number, columnIndex: number): boolean;
 }

package/lib/table/data/tablemodel/areamodel/cover-grid-body-model.d.ts

@@ -1,12 +1,13 @@
-import { AreaModelIf } from './area-model.if';
-import { CellRendererIf } from '../../../renderer/cell-render.if';
-import { CheckedType } from '../../common/checked-type';
-import { CheckboxModelIf } from '../../../checkbox/checkbox-model.if';
-import { FilterFunction } from '../../common/filter-function';
-import { SortItem } from '../../common/sort-item';
-import { AreaIdent } from '../area-ident.type';
-import { SorterService } from '../../../service/sorter.service';
+import { AreaModelIf } from './area-model.if.js';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { CheckedType } from '../../common/checked-type.js';
+import { CheckboxModelIf } from '../../../checkbox/checkbox-model.if.js';
+import { FilterFunction } from '../../common/filter-function.js';
+import { SortItem } from '../../common/sort-item.js';
+import { AreaIdent } from '../area-ident.type.js';
+import { SorterService } from '../../../service/sorter.service.js';
 
+/** @category Area models */
 export declare class CoverGridBodyModel<T> implements AreaModelIf {
     items: T[];
     cellRenderer: CellRendererIf;
@@ -17,6 +18,7 @@ export declare class CoverGridBodyModel<T> implements AreaModelIf {
     rowSelectionModel: CheckboxModelIf<any> | undefined;
     areaIdent: AreaIdent;
     filteredItems: T[];
+    /** @internal */
     protected sorterService: SorterService;
     constructor(items: T[], cellRenderer: CellRendererIf, coverWidth?: number, coverHeight?: number, width?: number, firstRowPaddingTop?: number);
     setParentWidth(widthInPixel: number): void;

package/lib/table/data/tablemodel/areamodel/has-default-row-height-if.d.ts

@@ -1,3 +1,4 @@
+/** @category Area models */
 export interface HasDefaultRowHeightIf {
     defaultRowHeight: number;
 }

package/lib/table/data/tablemodel/areamodel/object-array-holder.if.d.ts

@@ -1,3 +1,4 @@
+/** @category Area models */
 export interface ObjectArrayHolderIf<T> {
     getAllRows(): T[];
     getFilteredRows(): T[];

package/lib/table/data/tablemodel/cellgroup/cell-group-ext.d.ts

@@ -1,6 +1,7 @@
-import { CellGroupIf } from './cell-group.if';
-import { CellGroup } from './cell-group';
+import { CellGroupIf } from './cell-group.if.js';
+import { CellGroup } from './cell-group.js';
 
+/** @category Header groups */
 export declare class CellGroupExt extends CellGroup {
     rowIndex: number;
     childIndex: number;

package/lib/table/data/tablemodel/cellgroup/cell-group.d.ts

@@ -1,5 +1,6 @@
-import { CellGroupIf } from './cell-group.if';
+import { CellGroupIf } from './cell-group.if.js';
 
+/** @category Header groups */
 export declare class CellGroup implements CellGroupIf {
     data: any;
     property?: string | undefined;

package/lib/table/data/tablemodel/cellgroup/cell-group.if.d.ts

@@ -1,9 +1,37 @@
+/**
+ * One node of a grouped header ({@link AreaModelCellGroups}): a group with `children`, or a leaf with a `property`
+ * (a leaf becomes a column).
+ *
+ * @example
+ * const groups: CellGroupIf[] = [
+ *   { data: "Order", children: [{ data: "ID", property: "id" }, { data: "Date", property: "date" }] },
+ *   { data: "Customer", toggle: true, children: [
+ *     { data: "Customer", property: "customer", visibility: "always" },   // stays visible when collapsed
+ *     { data: "City", property: "city" }] }
+ * ];
+ * const columnDefs = CellgroupFactory.buildColumnDefs(CellgroupFactory.buildGroupExts(groups));
+ * const header = new AreaModelCellGroups("header", groups, columnDefs, 34);
+ *
+ * @see Training: [Header models: multi-row and grouped](https://gui.expert/training/header-groups/)
+ *
+ * @category Header groups
+ */
 export interface CellGroupIf {
+    /** The label of the group or column. */
     data: any;
+    /** Set on leaves only: the property shown in this column. */
     property?: string;
+    /** Show a ❯ toggle so that the user can collapse / expand the group. */
     toggle?: boolean;
+    /** Current state: collapsed. */
     closed?: boolean;
+    /**
+     * When is this child visible? `"always"` – also when the group is collapsed; `"inverted"` – only when collapsed
+     * (e.g. a summary column); `"normal"` / undefined – only when expanded.
+     */
     visibility?: "always" | "inverted" | "normal" | undefined;
+    /** Sub-groups or columns. */
     children?: CellGroupIf[] | undefined;
+    /** Internal: the implementation type of the node. */
     impl?: string;
 }

package/lib/table/data/tablemodel/cellgroup/cellgroup-factory.d.ts

@@ -1,7 +1,8 @@
-import { CellGroupIf } from './cell-group.if';
-import { ColumnDefIf } from '../column/column-def.if';
-import { CellGroupExt } from './cell-group-ext';
+import { CellGroupIf } from './cell-group.if.js';
+import { ColumnDefIf } from '../column/column-def.if.js';
+import { CellGroupExt } from './cell-group-ext.js';
 
+/** @category Header groups */
 export declare class CellgroupFactory {
     static buildColumnDefs(cellGroups: CellGroupIf[], ret?: ColumnDefIf[]): ColumnDefIf[];
     static buildGroupExts(cellGroups: CellGroupIf[], ret?: CellGroupExt[], deep?: number, parent?: CellGroupExt): CellGroupExt[];