@perspective-dev/viewer-datagrid 4.4.1 → 4.5.0

package/src/ts/event_handlers/sort.ts

@@ -37,7 +37,10 @@ export async function sortHandler(
     target: HTMLElement,
 ): Promise<void> {
     const meta = regularTable.getMeta(target);
-    if (!meta?.column_header) return;
+    if (!meta?.column_header) {
+        return;
+    }
+
     const column_name = meta.column_header[model._config.split_by.length];
     const sort_method =
         event.ctrlKey ||

package/src/ts/get_cell_config.ts

@@ -12,6 +12,7 @@
 
 import type { View, ViewConfig, Filter, Scalar } from "@perspective-dev/client";
 import type { CellConfigResult } from "./types.js";
+import { isMetaColumn } from "./model/meta_columns.js";
 
 interface ModelWithViewAndConfig {
     _view: View;
@@ -42,8 +43,14 @@ export default async function getCellConfig(
         })
         .filter((x): x is Filter => x !== undefined);
 
-    const column_index = group_by.length > 0 ? col_idx + 1 : col_idx;
-    const column_paths = Object.keys(r[0])[column_index];
+    // Filter out *all* meta columns before indexing into the row's
+    // keys — the DuckDB virtual server's JSON output now includes
+    // per-level `__ROW_PATH_<n>__` columns alongside the
+    // `__ROW_PATH__` sidecar, so the previous `+1` skip (which
+    // assumed exactly one leading meta column) lands on a meta key
+    // when group_by has multiple levels.
+    const user_keys = Object.keys(r[0]).filter((k) => !isMetaColumn(k));
+    const column_paths = user_keys[col_idx];
     const result: CellConfigResult = {
         row: r[0] as Record<string, unknown>,
         column_names: [],
@@ -60,7 +67,7 @@ export default async function getCellConfig(
                 return pivot_value ? [pivot, "==", pivot_value] : undefined;
             })
             .filter((x): x is Filter => x !== undefined)
-            .filter(([, , value]) => value !== "__ROW_PATH__");
+            .filter(([, , value]) => !isMetaColumn(value as string));
     }
 
     const filter = _config.filter.concat(row_filters).concat(column_filters);

package/src/ts/model/column_overrides.ts

@@ -10,11 +10,7 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-import type {
-    ColumnOverrides,
-    DatagridPluginElement,
-    RegularTable,
-} from "../types.js";
+import type { ColumnOverrides, DatagridPluginElement } from "../types.js";
 
 interface RegularTableWithOverrides {
     restoreColumnSizes(overrides: Record<number, number | undefined>): void;
@@ -60,6 +56,7 @@ export function restore_column_size_overrides(
                 | undefined;
         } else {
             const index = this.model!._column_paths.indexOf(key);
+
             // Skip keys that don't resolve to a known column — e.g. on the
             // first draw after `activate`, `_column_paths` has not yet been
             // populated by the data listener, so we leave any existing
@@ -68,6 +65,7 @@ export function restore_column_size_overrides(
             if (index === -1) {
                 continue;
             }
+
             overrides[index + tree_header_offset] = old_sizes[key] as
                 | number
                 | undefined;

package/src/ts/model/create.ts

@@ -29,21 +29,36 @@ import {
 import type { HTMLPerspectiveViewerElement } from "@perspective-dev/viewer";
 
 function arraysChanged<T>(a: T[], b: T[]): boolean {
-    if (a.length !== b.length) return true;
+    if (a.length !== b.length) {
+        return true;
+    }
+
     for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i]) return true;
+        if (a[i] !== b[i]) {
+            return true;
+        }
     }
+
     return false;
 }
 
 function nestedArraysChanged<T>(a: T[][], b: T[][]): boolean {
-    if (a.length !== b.length) return true;
+    if (a.length !== b.length) {
+        return true;
+    }
+
     for (let i = 0; i < a.length; i++) {
-        if (a[i].length !== b[i].length) return true;
+        if (a[i].length !== b[i].length) {
+            return true;
+        }
+
         for (let j = 0; j < a[i].length; j++) {
-            if (a[i][j] !== b[i][j]) return true;
+            if (a[i][j] !== b[i][j]) {
+                return true;
+            }
         }
     }
+
     return false;
 }
 
@@ -75,6 +90,7 @@ class ElemFactoryImpl implements ElemFactory {
         if (!this._elements[this._index]) {
             this._elements[this._index] = document.createElement(this._name);
         }
+
         const elem = this._elements[this._index];
         this._index += 1;
         return elem;
@@ -216,6 +232,7 @@ export async function createModel(
         }),
         _series_color_map: new Map<string, string>(),
         _series_color_seed: new Map<string, number>(),
+
         // get_psp_type,
         _div_factory: extend._div_factory || new ElemFactoryImpl("div"),
     }) as DatagridModel;

package/src/ts/{plugin/column_style_controls.ts → model/meta_columns.ts}

@@ -10,67 +10,38 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-import type { ColumnType } from "@perspective-dev/client";
-import type { DatagridPluginElement } from "../types.js";
+/**
+ * Single-source-of-truth predicate for "this column is metadata, hide
+ * it from the user-visible grid." Five distinct names show up across
+ * the perspective protocol; older datagrid code filtered them by
+ * exact-match in three places, which only worked when the wire shape
+ * was the JSON-sidecar form (`__ROW_PATH__` array-of-arrays).
+ *
+ * The DuckDB virtual-server backend additionally surfaces per-level
+ * `__ROW_PATH_<n>__` columns directly in `to_columns_string` /
+ * `to_json` output (a side effect of keeping them in the frozen Arrow
+ * batch so that `to_arrow` consumers — viewer-charts via
+ * `with_typed_arrays` — see them inline, matching native
+ * `perspective-server`'s `to_arrow` behavior). Without this helper,
+ * those per-level columns slip through the legacy exact-match filters
+ * and render as user columns to the right of the grid.
+ *
+ * Match list:
+ *   - `__ROW_PATH__`     — JSON sidecar; used by the tree header.
+ *   - `__ROW_PATH_<n>__` — per-level columns from the virtual server's
+ *                          inline-arrow shape.
+ *   - `__ID__`           — per-row identity column.
+ *   - `__GROUPING_ID__`  — internal SQL-rollup discriminator. The
+ *                          virtual server strips it server-side, but
+ *                          we cover it defensively in case a future
+ *                          backend leaks it.
+ *
+ * User columns named with leading/trailing double-underscores (e.g.
+ * `__user_col__`) are *not* matched — the regex requires the exact
+ * stems above.
+ */
+const META_COLUMN_RE = /^__(?:ROW_PATH(?:_\d+)?|ID|GROUPING_ID)__$/;
 
-interface NumberStyleOpts {
-    datagrid_number_style: {
-        fg_gradient: number;
-        pos_fg_color: string;
-        neg_fg_color: string;
-        number_fg_mode: string;
-        bg_gradient: number;
-        pos_bg_color: string;
-        neg_bg_color: string;
-        number_bg_mode: string;
-    };
-    number_string_format: boolean;
-}
-
-interface DatetimeStyleOpts {
-    datagrid_datetime_style?: {
-        color: string;
-        bg_color: string;
-    };
-    datagrid_string_style?: {
-        color: string;
-        bg_color: string;
-    };
-}
-
-export type ColumnStyleOpts = NumberStyleOpts | DatetimeStyleOpts | null;
-
-export default function column_style_opts(
-    this: DatagridPluginElement,
-    type: ColumnType,
-    _group: string,
-): ColumnStyleOpts {
-    if (type === "integer" || type === "float") {
-        return {
-            datagrid_number_style: {
-                fg_gradient: 0,
-                pos_fg_color: this.model!._pos_fg_color[0],
-                neg_fg_color: this.model!._neg_fg_color[0],
-                number_fg_mode: "color",
-                bg_gradient: 0,
-                pos_bg_color: this.model!._pos_bg_color[0],
-                neg_bg_color: this.model!._neg_bg_color[0],
-                number_bg_mode: "disabled",
-            },
-            number_string_format: true,
-        };
-    } else if (type === "date" || type === "datetime" || type === "string") {
-        const control =
-            type === "date" || type === "datetime"
-                ? "datagrid_datetime_style"
-                : `datagrid_string_style`;
-        return {
-            [control]: {
-                color: this.model!._color[0],
-                bg_color: this.model!._color[0],
-            },
-        } as DatetimeStyleOpts;
-    } else {
-        return null;
-    }
+export function isMetaColumn(name: string): boolean {
+    return META_COLUMN_RE.test(name);
 }

package/src/ts/model/toolbar.ts

@@ -10,6 +10,7 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+import { HTMLPerspectiveViewerElement } from "@perspective-dev/viewer";
 import type {
     DatagridModel,
     DatagridPluginElement,
@@ -26,7 +27,10 @@ export const EDIT_MODES: readonly EditMode[] = [
 ] as const;
 
 function isSelectRowTreeAvailable(model?: DatagridModel): boolean {
-    if (!model) return false;
+    if (!model) {
+        return false;
+    }
+
     return (
         model._config.group_by.length > 0 &&
         model._config.group_rollup_mode !== "flat"
@@ -45,10 +49,11 @@ export function toggle_edit_mode(
             EDIT_MODES[idx] === "SELECT_ROW_TREE" &&
             !isSelectRowTreeAvailable(this.model)
         );
+
         mode = EDIT_MODES[idx];
     }
 
-    (this.parentElement as any)?.setSelection?.();
+    (this.parentElement as HTMLPerspectiveViewerElement)?.setSelection?.();
     this._edit_mode = mode;
     if (this.model) {
         this.model._edit_mode = mode;
@@ -59,6 +64,10 @@ export function toggle_edit_mode(
         };
     }
 
+    (this.parentElement as HTMLPerspectiveViewerElement)?.restore?.({
+        plugin_config: { edit_mode: mode },
+    });
+
     if (this._edit_button !== undefined) {
         this._edit_button.dataset.editMode = mode;
     }

package/src/ts/plugin/activate.ts

@@ -91,7 +91,9 @@ export async function activate(
             area: SelectionArea,
             isDeselect: boolean,
         ) => {
-            if (model._edit_mode !== "SELECT_ROW_TREE") return;
+            if (model._edit_mode !== "SELECT_ROW_TREE") {
+                return;
+            }
 
             // Store the selected row identity on the model so it persists
             // even when the selected row scrolls out of the viewport.

package/src/ts/plugin/column_config_schema.ts

@@ -0,0 +1,187 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+import type { ColumnType } from "@perspective-dev/client";
+import type { DatagridPluginElement } from "../types.js";
+
+interface ViewerConfigLike {
+    group_by?: string[];
+    group_rollup_mode?: string;
+}
+
+type ControlSpec = Record<string, unknown> & { kind: string };
+
+export interface ColumnConfigSchema {
+    fields: ControlSpec[];
+}
+
+/**
+ * Plugin schema for the Datagrid column-settings sidebar. Returns the
+ * controls the viewer should render in the Style tab for a given column.
+ *
+ * Each entry in `fields` is a `ControlSpec` discriminated by `kind`.
+ * Composite kinds (`NumberStyle`, `DatetimeFormat`, `StringFormat`,
+ * `NumberFormat`, `AggregateDepth`) own a fixed key namespace and
+ * carry only their `default`. Primitive kinds (`Enum`, `Bool`, `Color`,
+ * etc.) carry their own `key` (storage) and `label` (UI) inline.
+ *
+ * Aggregate Depth is plugin-owned — surfaced only inside the Datagrid
+ * because rollup-mode pivots are a Datagrid concern. Emitted only when
+ * the active view has a non-empty `group_by` and rollup mode is `Rollup`.
+ */
+interface ColumnStats {
+    abs_max?: number;
+}
+
+export default function column_config_schema(
+    this: DatagridPluginElement,
+    type: ColumnType,
+    _group: string | undefined,
+    _column_name: string,
+    current_value: Record<string, unknown> | null,
+    viewer_config?: ViewerConfigLike,
+    column_stats?: ColumnStats,
+): ColumnConfigSchema {
+    const fields: ControlSpec[] = [];
+
+    if (type === "integer" || type === "float") {
+        const pos_fg = this.model!._pos_fg_color[0];
+        const neg_fg = this.model!._neg_fg_color[0];
+        const pos_bg = this.model!._pos_bg_color[0];
+        const neg_bg = this.model!._neg_bg_color[0];
+
+        fields.push({
+            kind: "Enum",
+            key: "number_fg_mode",
+            default: "color",
+            variants: [
+                { value: "disabled", label: "Disabled" },
+                { value: "color", label: "Color" },
+                { value: "bar", label: "Bar" },
+                { value: "label-bar", label: "Gradient" },
+            ],
+        });
+
+        const fg_mode = (current_value?.number_fg_mode as string) ?? "color";
+        if (fg_mode !== "disabled") {
+            fields.push({
+                kind: "ColorRange",
+                key_pos: "pos_fg_color",
+                key_neg: "neg_fg_color",
+                default_pos: pos_fg,
+                default_neg: neg_fg,
+                is_gradient: false,
+            });
+        }
+
+        if (fg_mode === "bar" || fg_mode === "label-bar") {
+            fields.push({
+                kind: "Number",
+                key: "fg_gradient",
+                default: column_stats?.abs_max ?? 0,
+                include: true,
+            });
+        }
+
+        fields.push({
+            kind: "Enum",
+            key: "number_bg_mode",
+            default: "disabled",
+            variants: [
+                { value: "disabled", label: "Disabled" },
+                { value: "color", label: "Color" },
+                { value: "gradient", label: "Gradient" },
+                { value: "pulse", label: "Pulse" },
+            ],
+        });
+
+        const bg_mode = (current_value?.number_bg_mode as string) ?? "disabled";
+        if (bg_mode !== "disabled") {
+            fields.push({
+                kind: "ColorRange",
+                key_pos: "pos_bg_color",
+                key_neg: "neg_bg_color",
+                default_pos: pos_bg,
+                default_neg: neg_bg,
+                is_gradient: bg_mode === "gradient" || bg_mode === "pulse",
+            });
+        }
+
+        if (bg_mode === "gradient") {
+            fields.push({
+                kind: "Number",
+                key: "bg_gradient",
+                include: true,
+                default: column_stats?.abs_max ?? 0,
+            });
+        }
+
+        fields.push({ kind: "NumberFormat" });
+    } else if (type === "date" || type === "datetime") {
+        fields.push({ kind: "DatetimeFormat" });
+
+        fields.push({
+            kind: "Enum",
+            key: "datetime_color_mode",
+            default: "none",
+            variants: [
+                { value: "none", label: "None" },
+                { value: "foreground", label: "Foreground" },
+                { value: "background", label: "Background" },
+            ],
+        });
+
+        const dt_mode =
+            (current_value?.datetime_color_mode as string) ?? "none";
+
+        if (dt_mode !== "none") {
+            fields.push({
+                kind: "Color",
+                key: "color",
+                default: this.model!._color[0],
+            });
+        }
+    } else if (type === "string") {
+        fields.push({ kind: "StringFormat" });
+
+        fields.push({
+            kind: "Enum",
+            key: "string_color_mode",
+            default: "none",
+            variants: [
+                { value: "none", label: "None" },
+                { value: "foreground", label: "Foreground" },
+                { value: "background", label: "Background" },
+                { value: "series", label: "Series" },
+            ],
+        });
+
+        const str_mode = (current_value?.string_color_mode as string) ?? "none";
+        if (str_mode !== "none") {
+            fields.push({
+                kind: "Color",
+                key: "color",
+                default: this.model!._color[0],
+            });
+        }
+    }
+
+    const group_by = viewer_config?.group_by ?? [];
+    const is_rollup =
+        (viewer_config?.group_rollup_mode ?? "rollup") === "rollup";
+
+    if (group_by.length > 0 && is_rollup) {
+        fields.push({ kind: "AggregateDepth" });
+    }
+
+    return { fields };
+}

package/src/ts/plugin/draw.ts

@@ -47,6 +47,7 @@ export async function draw(
         this.regular_table.scrollLeft = 0;
         this._reset_scroll_left = false;
     }
+
     if (this._reset_select) {
         this.regular_table.dispatchEvent(
             new CustomEvent("psp-deselect-all", { bubbles: false }),

package/src/ts/plugin/restore.ts

@@ -92,16 +92,20 @@ export function restore(
         }
     }
 
-    if ("edit_mode" in token && token.edit_mode) {
-        if (EDIT_MODES.indexOf(token.edit_mode) !== -1) {
+    if ("edit_mode" in token) {
+        if (EDIT_MODES.indexOf(token.edit_mode!) !== -1) {
             toggle_edit_mode.call(this, token.edit_mode);
         } else {
             console.error("Unknown edit mode " + token.edit_mode);
         }
+    } else {
+        toggle_edit_mode.call(this, "READ_ONLY");
     }
 
     if ("scroll_lock" in token) {
         toggle_scroll_lock.call(this, token.scroll_lock);
+    } else {
+        toggle_scroll_lock.call(this, false);
     }
 
     const datagrid = this.regular_table;

package/src/ts/plugin/save.ts

@@ -11,11 +11,7 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 import { save_column_size_overrides } from "../model/column_overrides.js";
-import type {
-    DatagridPluginElement,
-    DatagridPluginConfig,
-    EditMode,
-} from "../types.js";
+import type { DatagridPluginElement, DatagridPluginConfig } from "../types.js";
 
 export function save(
     this: DatagridPluginElement,

package/src/ts/style_handlers/body.ts

@@ -185,8 +185,11 @@ export function applyBodyCellStyles(
                     td.classList.toggle("psp-select-region-inactive", isSub);
                 }
             }
-        } else {
-            td.classList.toggle("psp-select-region", false);
+            // } else if (
+            //     model._edit_mode === "READ_ONLY" ||
+            //     model._edit_mode === "EDIT"
+            // ) {
+            //     td.classList.toggle("psp-select-region", false);
         }
 
         // Apply editable styling (if editable)
@@ -212,6 +215,7 @@ export function applyBodyCellStyles(
                     if (isEditable !== td.hasAttribute("contenteditable")) {
                         td.toggleAttribute("contenteditable", isEditable);
                     }
+
                     td.classList.toggle("boolean-editable", false);
                 }
             } else {

package/src/ts/style_handlers/column_header.ts

@@ -72,7 +72,10 @@ export function style_selected_column(
                 if (model._config.columns.length > 1) {
                     for (const r of regularTable.querySelectorAll("td")) {
                         const meta = regularTable.getMeta(r);
-                        if (!meta?.column_header) continue;
+                        if (!meta?.column_header) {
+                            continue;
+                        }
+
                         const isOpen =
                             meta.column_header[
                                 meta.column_header.length - 2
@@ -104,8 +107,9 @@ export function styleColumnHeaderRow(
             !metadata ||
             metadata.type === "body" ||
             metadata.type === "row_header"
-        )
+        ) {
             continue;
+        }
 
         const column_name =
             metadata.column_header?.[model._config.split_by.length];

package/src/ts/style_handlers/consolidated.ts

@@ -96,6 +96,7 @@ export function createConsolidatedStyleListener(
                         metadata,
                     });
                 }
+
                 groupHeaderRows.push(rowData);
             }
         }

package/src/ts/style_handlers/editable.ts

@@ -27,7 +27,9 @@ export function applyColumnHeaderStyles(
     regularTable: RegularTableElement,
     viewer: HTMLPerspectiveViewerElement,
 ): void {
-    if (headerRows.length === 0) return;
+    if (headerRows.length === 0) {
+        return;
+    }
 
     // Style selected column for settings panel
     const selectedColumn = model._column_settings_selected_column;
@@ -68,7 +70,9 @@ export function applyColumnHeaderStyles(
             for (let i = 0; i < titlesRow.cells.length; i++) {
                 const title = titlesRow.cells[i]?.element;
                 const editBtn = editBtnsRow.cells[i]?.element;
-                if (!title || !editBtn) continue;
+                if (!title || !editBtn) {
+                    continue;
+                }
 
                 const open = title.textContent === selectedColumn;
                 title.classList.toggle("psp-menu-open", open);

package/src/ts/style_handlers/focus.ts

@@ -37,6 +37,7 @@ export function applyFocusStyle(
                 if (host.activeElement !== td) {
                     td.focus({ preventScroll: true });
                 }
+
                 return;
             }
         }
@@ -82,6 +83,7 @@ export function focusSelectedCell(
                     if (host.activeElement !== cell) {
                         (cell as HTMLElement).focus({ preventScroll: true });
                     }
+
                     return true;
                 }
             }

package/src/ts/style_handlers/group_header.ts

@@ -28,12 +28,14 @@ export function applyGroupHeaderStyles(
     let marked = new Set<number>();
 
     for (let y = 0; y < headerRows.length; y++) {
-        const { row, cells } = headerRows[y];
+        const { cells } = headerRows[y];
         const tops = new Set<number>();
 
         for (let x = 0; x < cells.length; x++) {
             const { element: td, metadata } = cells[x];
-            if (!metadata) continue;
+            if (!metadata) {
+                continue;
+            }
 
             td.style.backgroundColor = "";
 
@@ -63,13 +65,17 @@ export function applyGroupHeaderStyles(
 
             // Calculate spanning for psp-is-top
             let xx = x;
-            for (; m[y] && m[y][xx]; ++xx);
+            for (; m[y] && m[y][xx]; ++xx) {}
+
             tops.add(xx);
 
             const cell = td;
             for (let tx = xx; tx < xx + cell.colSpan; ++tx) {
                 for (let ty = y; ty < y + cell.rowSpan; ++ty) {
-                    if (!m[ty]) m[ty] = [];
+                    if (!m[ty]) {
+                        m[ty] = [];
+                    }
+
                     m[ty][tx] = true;
                 }
             }