dom-primitive-bindings 1.0.0 → 1.3.1

package/README.md

@@ -1,61 +1,91 @@
 # DOM Primitive Bindings
 
-> Modern, lightweight, delegated event engine for browser DOMs. Attach exactly one listener per event type to any container; let bubbling handle matching, runners, and extraction with zero re-binding overhead.
+> Modern, lightweight, single-listener delegated event engine for browser DOMs. Driven by declarative `bindings.json` configurations with zero DOM manipulation and zero schema extraction.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)]()
-[![Single Source of Truth](https://img.shields.io/badge/Version-v1-blue.svg)]()
+[![npm version](https://img.shields.io/npm/v/dom-primitive-bindings.svg?style=flat-square)](https://www.npmjs.com/package/dom-primitive-bindings)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![Single Source of Truth](https://img.shields.io/badge/Version-v3-blue.svg?style=flat-square)]()
+[![Documentation](https://img.shields.io/badge/Docs-Architecture%20%26%20Stories-green.svg?style=flat-square)](./docs/index.html)
 
 ---
 
-## 🎯 The Core Concept
+## 📖 The 4-Part Event Delegation Story
 
-Traditional client-side code attaches listeners to every button, link, and input. When tables are refreshed, cards are added, or modals render dynamic markup, those listeners break or leak memory unless manually re-attached.
+Explore the interactive interactive story chapters in [`docs/stories/`](./docs/index.html):
 
-**DOM Primitive Bindings** inverts the architecture:
-- Attach **one listener** per event type to the parent container (`table`, `form`, `card-grid`).
-- As events bubble up, `closest(selector)` identifies target elements.
-- The associated `runner` executes and forwards data cleanly to `onExtract`.
-- Dynamically created DOM elements are supported immediately with **zero re-binding**.
+1. **[Chapter 1: The Everyday Habit & The Listener Trap](./docs/stories/01-the-listener-trap.html)**  
+   Why attaching listeners to individual elements causes memory leaks, double-trigger cascades, and dead-zones on dynamic elements.
+2. **[Chapter 2: The Delegation Epiphany](./docs/stories/02-the-delegation-epiphany.html)**  
+   Harnessing browser event bubbling: 1 container listener catching bubbling events forever.
+3. **[Chapter 3: The Staged Pipeline Architecture](./docs/stories/03-the-staged-pipeline.html)**  
+   Inside the decoupled 4-stage pipeline: `guards` $\to$ `prepare` $\to$ `listeners` $\to$ `dispatch`.
+4. **[Chapter 4: The Joy of Declarative JSON](./docs/stories/04-declarative-json-bindings.html)**  
+   Moving from imperative JavaScript arrays to clean, serializable `bindings.json` specifications with a live interactive demo.
 
 ---
 
-## 🏗️ Staged Architecture (`src/v1/`)
+## 🎯 The Philosophy: The Wiring Layer
 
-The repository strictly enforces a staged pipeline where every directory contains an `index.js` and all files export a single function as `default`:
+A common mistake in UI architecture is conflating **event wiring** with **DOM manipulation** or **data extraction**:
+
+- **`dom-primitive-bindings` (This Repository):**  
+  Pure **Wiring Layer**. Attaches one container listener per event type, matches bubbling targets via `closest(selector)`, and delivers `{ event, targetElement }`. It does **not** manipulate DOM elements and does **not** extract table schemas into objects.
+- **`dom-primitive-engine` (Sibling Repository):**  
+  Pure **Extraction Layer**. Receives the matched target element and executes declarative instruction pipelines (e.g. `closest("tr")`, `querySelectorAll("td")`, column mapping) to produce clean JSON.
+
+```text
+[ User Action in Browser ]
+            │
+            ▼
+┌───────────────────────────────┐
+│    dom-primitive-bindings     │ ◄── Wiring Layer: Catches event & matches target
+│  (guards → prepare → dispatch)│
+└──────────────┬────────────────┘
+               │ delivers { event, targetElement }
+               ▼
+┌───────────────────────────────┐
+│     Consumer / App Logic      │ ◄── Extraction (dom-primitive-engine) or App Handler
+└───────────────────────────────┘
+```
+
+---
+
+## 🏗️ Staged Architecture (`src/v3/`)
+
+The engine enforces a staged pipeline where every directory contains an `index.js` and all files export a single function as `default`:
 
 ```text
-src/
-└── v1/
-    ├── guards/               # Validates container and bindings array
-    │   ├── container/        # Validates and resolves 1st input (container / ID)
-    │   ├── bindings/         # Validates 2nd input (bindings array)
-    │   └── index.js
-    ├── prepare/              # Groups bindings by event type into Map
-    │   ├── groupBindings.js
-    │   └── index.js
-    ├── listeners/            # Attaches single listener per event type to container
-    │   ├── attachListener.js
-    │   └── index.js
-    ├── dispatch/             # Handles event bubbling, runner execution & extraction
-    │   ├── getStartInput.js
-    │   ├── getClientData.js
-    │   ├── executeBinding.js
-    │   └── index.js
-    ├── register/             # Exposes module onto window.ks.domPrimitiveBindings
-    │   ├── meta.js
-    │   └── index.js
-    └── index.js              # Orchestrator exporting bindEvents
+src/v3/
+├── guards/               # Validates container & bindings array
+│   ├── container/        # Resolves 1st input (container ID or DOM element)
+│   ├── bindings/         # Filters and validates 2nd input (bindings array)
+│   └── index.js
+├── prepare/              # Groups bindings by event type into Map
+│   ├── groupBindings.js
+│   └── index.js
+├── listeners/            # Attaches single container listener per event type
+│   ├── attachListener.js
+│   └── index.js
+├── dispatch/             # Handles event bubbling, target matching & execution
+│   ├── getStartInput.js
+│   ├── getClientData.js
+│   ├── executeBinding.js
+│   └── index.js
+├── register/             # Exposes module onto window.ks.domPrimitiveBindings
+│   ├── meta.js
+│   └── index.js
+└── index.js              # Orchestrator
 ```
 
 ### Key Design Disciplines
 1. **Zero Comments:** The folder hierarchy and descriptive file names convey the full narrative without inline code comments.
 2. **Folder Discipline:** Every folder contains an `index.js` public gateway.
 3. **Single Function Default Export:** No default export objects; every file exports a single function.
+4. **Declarative JSON:** Bindings are defined in serializable `bindings.json` files.
 
 ---
 
-## 🚀 Interactive Browser Samples (`samples/v1/`)
+## 🚀 Interactive Browser Samples (`samples/v3/`)
 
 Start the Vite development server to view and interact with real browser DOM events:
 
@@ -65,47 +95,55 @@ npm run dev
 ```
 
 Open in Chrome or Edge:
-- **`samples/v1/tableWithSearch/`** — Delegated table row clicks and live Enter-key search input.
-- **`samples/v1/cardGrid/`** — Dynamic card insertion into DOM with instant delegated action buttons.
-- **`samples/v1/formEvents/`** — Live form field inputs, dropdown selection changes, and submit/clear buttons.
+- **`samples/v3/tableWithSearch/`** — Declarative table row clicks and live Enter-key search input loaded from `bindings.json`.
+- **`samples/v3/cardGrid/`** — Declarative card button and card body click bindings loaded from `bindings.json`.
+- **`samples/v3/formEvents/`** — Declarative input, change, and button click bindings loaded from `bindings.json`.
 
 ---
 
 ## 📦 Usage
 
-### Browser (ES Module / Script)
+### 1. Declare `bindings.json`
 
-```html
-<script type="module" src="./docs/dist/v1/min.js"></script>
-<script type="module">
-  const bindings = [
-    {
-      event: "click",
-      selector: ".btn-cart",
-      runner: (target) => ({ productId: target.dataset.id }),
-      onExtract: (data) => console.log("Added to cart:", data)
-    }
-  ];
-
-  window.ks.domPrimitiveBindings.bindEvents("products-container", bindings);
-</script>
+```json
+[
+  {
+    "event": "click",
+    "selector": ".btn-action"
+  },
+  {
+    "event": "keydown",
+    "selector": "input[type='search']"
+  }
+]
 ```
 
-### Module Import
+### 2. Run with `bindEvents`
 
 ```javascript
+import bindings from "./bindings.json" with { type: "json" };
 import { bindEvents } from "dom-primitive-bindings";
 
-bindEvents(containerElement, [
-  {
-    event: "click",
-    selector: ".action-btn",
-    runner: (btn) => btn.dataset.action,
-    onExtract: (action) => console.log("Action:", action)
-  }
-]);
+bindEvents("container-id", bindings);
 ```
 
+Or via global browser script:
+
+```html
+<script type="module" src="./docs/dist/v3/min.js"></script>
+<script type="module">
+  import bindings from "./bindings.json" with { type: "json" };
+  window.ks.domPrimitiveBindings.bindEvents("container-id", bindings);
+</script>
+```
+
+---
+
+## 📚 Technical Specifications
+
+- **[Architecture & Design Story](./docs/architecture.md)**: Deep dive into the 4 internal stages and data flow.
+- **[Binding Specification Schema](./docs/binding-spec.md)**: Complete property reference for `bindings.json`.
+
 ---
 
 ## 🧪 Testing & Build
@@ -114,7 +152,7 @@ bindEvents(containerElement, [
 # Run unit tests
 npm test
 
-# Build production bundle to docs/dist/v1/min.js
+# Build production bundle to docs/dist/v3/min.js
 npm run build
 ```
 
@@ -123,4 +161,3 @@ npm run build
 ## 📄 License
 
 MIT © KeshavSoft
-

package/docs/architecture.md

@@ -0,0 +1,111 @@
+# Architecture & Design Story — DOM Primitive Bindings
+
+This document details the architectural philosophy, data flow, and design trade-offs behind **DOM Primitive Bindings**.
+
+---
+
+## 1. The Core Architectural Philosophy
+
+### Separation of Concerns: The Wiring Layer vs. The Extraction Layer
+
+Modern frontend architectures fail when they blur the boundary between **how events are wired** and **how data is extracted or mutated**:
+
+```text
+┌─────────────────────────────────┐
+│           Browser DOM           │  <-- Stateful View (Table, Form, Cards)
+└────────────────┬────────────────┘
+                 │ user interaction (click, input, keydown)
+                 ▼
+┌─────────────────────────────────┐
+│     dom-primitive-bindings      │  <-- Responsibility: The Wiring Layer
+│  (guards → prepare → dispatch)  │      • Single listener on container
+└────────────────┬────────────────┘      • Matches closest(selector)
+                 │ passes { event, targetElement }
+                 ▼
+┌─────────────────────────────────┐
+│      dom-primitive-engine       │  <-- Responsibility: The Extraction Layer
+│    (declarative instructions)   │      • Traverses DOM (tr, td)
+└────────────────┬────────────────┘      • Produces clean JSON object
+                 │ outputs clean Plain Data
+                 ▼
+┌─────────────────────────────────┐
+│    Business Logic / API Call    │  <-- Consumes Plain Data
+└─────────────────────────────────┘
+```
+
+By strictly separating event wiring into `dom-primitive-bindings`:
+1. **Zero DOM manipulation**: Bindings never alter, insert, or delete DOM elements.
+2. **Zero schema extraction**: Bindings never parse table cells or form schemas into business models.
+3. **Pure delegation**: Exactly **one listener per event type** is attached to the parent container. Bubbling handles target matching.
+
+---
+
+## 2. Why Delegated Bindings over Element Listeners?
+
+| Approach | Memory Usage | Dynamic Element Support | Duplicate Fire Risk |
+| :--- | :--- | :--- | :--- |
+| **Direct Listeners** (`element.addEventListener`) | High ($O(N)$ listeners) | Fails on newly added DOM elements | High (re-attaching duplicates listeners) |
+| **DOM Primitive Bindings** (Container Delegation) | Minimal ($O(1)$ listener per event type) | Works instantly on dynamic elements | Zero (single stable container listener) |
+
+---
+
+## 3. The 4-Stage Internal Pipeline (`src/v3/`)
+
+The engine operates on a strictly staged, functional pipeline where every folder contains an `index.js` and exports a single function as `default`:
+
+```text
+src/v3/
+├── guards/               # Validates container & bindings array
+│   ├── container/        # Resolves 1st input (container ID or DOM element)
+│   ├── bindings/         # Filters and validates 2nd input (bindings array)
+│   └── index.js
+├── prepare/              # Groups bindings by event type into Map
+│   ├── groupBindings.js
+│   └── index.js
+├── listeners/            # Attaches single container listener per event type
+│   ├── attachListener.js
+│   └── index.js
+├── dispatch/             # Handles event bubbling, target matching & execution
+│   ├── getStartInput.js
+│   ├── getClientData.js
+│   ├── executeBinding.js
+│   └── index.js
+├── register/             # Exposes module onto window.ks.domPrimitiveBindings
+│   ├── meta.js
+│   └── index.js
+└── index.js              # Orchestrator
+```
+
+### Stage Details
+
+1. **`guards/`**: Validates inputs before any DOM mutation occurs.
+   - `container/`: Resolves string IDs via `document.getElementById` or verifies existing element.
+   - `bindings/`: Filters invalid items and ensures at least one valid binding exists.
+2. **`prepare/`**: Groups bindings into a `Map<eventType, bindings[]>`.
+   - If 10 separate selectors listen for `click`, they are aggregated under the single `"click"` event group.
+3. **`listeners/`**: Attaches exactly one native event listener to the container per event type.
+4. **`dispatch/`**:
+   - Intercepts the bubbling event.
+   - Resolves matching element via `event.target.closest(binding.selector)`.
+   - Resolves starting input (`event` for keyboard events, `matchElement` for clicks).
+   - Invokes runner and forwards data to `onExtract`.
+
+---
+
+## 4. Responsibility Boundaries
+
+| Actor | What It Does | What It NEVER Does |
+| :--- | :--- | :--- |
+| **Container Element** | Acts as the stable anchor for bubbling events | Does not know about inner button schemas |
+| **`bindings.json`** | Declares `event` and `selector` | Does not execute imperative logic |
+| **`dom-primitive-bindings`** | Resolves target, manages delegation pipeline | Does not extract table rows or mutate markup |
+| **`dom-primitive-engine`** | Extracts clean JSON data from the matched target | Does not manage event listeners |
+
+---
+
+## 5. Version Evolution (`v3` as Single Source of Truth)
+
+- **v1**: Staged architecture established with zero code comments and single-function default exports.
+- **v2**: Removed accidental DOM manipulation and cell extraction from samples, solidifying the pure delegation boundary.
+- **v3**: Declarative JSON transformation. Replaced imperative `.js` event arrays with pure, serializable `bindings.json` configurations.
+

package/docs/binding-spec.md

@@ -0,0 +1,86 @@
+# Binding Specification — DOM Primitive Bindings
+
+This document defines the normative schema and runtime behavior for declarative `bindings.json` files.
+
+---
+
+## 1. Schema Overview
+
+A bindings file is an array of binding specification objects:
+
+```json
+[
+  {
+    "event": "click",
+    "selector": ".ks-btn-show",
+    "root": "element",
+    "clientData": {
+      "context": "tableRow"
+    }
+  }
+]
+```
+
+---
+
+## 2. Property Definitions
+
+### `event` (Required)
+- **Type**: `string`
+- **Description**: The standard browser DOM event name to listen for on the container (e.g. `"click"`, `"keydown"`, `"input"`, `"change"`, `"submit"`).
+- **Behavior**: The engine groups all bindings with the same `event` name under a single native event listener on the container element.
+
+### `selector` (Required)
+- **Type**: `string`
+- **Description**: Standard CSS selector used by `event.target.closest(selector)` to identify whether the bubbling event originated from or within a target element.
+- **Examples**:
+  - `".ks-btn-show"`
+  - `"input[type='search'], input"`
+  - `".btn-action"`
+  - `".product-card"`
+
+### `root` (Optional)
+- **Type**: `string` (`"element"` | `"event"`)
+- **Default**: `"element"` (automatically defaults to `"event"` for key events such as `keydown`, `keyup`, `keypress`).
+- **Description**: Determines what is passed as the first argument to the runner function:
+  - `"element"`: passes the matched DOM element (`matchElement`).
+  - `"event"`: passes the native browser `Event` object.
+
+### `clientData` (Optional)
+- **Type**: `object`
+- **Description**: Arbitrary user-defined context passed along into the dispatch pipeline. The engine merges this into the client context object alongside `event` and `targetElement`.
+
+### `instructions` (Optional)
+- **Type**: `array`
+- **Description**: Declarative extraction instructions intended for handoff to `dom-primitive-engine`.
+
+---
+
+## 3. Runtime Dispatch Lifecycle
+
+When an event fires inside the container:
+
+```text
+Browser Event Fires
+       │
+       ▼
+Container Listener Intercepts (listeners/attachListener.js)
+       │
+       ▼
+Find Matching Element: event.target.closest(binding.selector)
+       │
+       ├── No match / not inside container ──> Discard (continue)
+       │
+       ▼
+Resolve Start Input (dispatch/getStartInput.js)
+       │
+       ├── Key event or root === "event" ──> Pass event
+       └── Otherwise ──> Pass matchElement
+       │
+       ▼
+Execute Runner (dispatch/executeBinding.js)
+       │
+       ▼
+Forward to onExtract(result, event, matchElement)
+```
+

package/docs/dist/min.js

@@ -1,12 +1,13 @@
 const u = {
   name: "dom-primitive-bindings",
-  version: "1.0.0"
+  version: "3.0.0"
 }, c = (t, n = u) => {
+  var e;
   if (!(!t || typeof globalThis > "u"))
     return globalThis.ks ?? (globalThis.ks = {}), globalThis.ks.domPrimitiveBindings = {
       meta: n,
       bindEvents: t
-    }, globalThis.ks.domPrimitiveBindings;
+    }, (e = globalThis.ks).bindEvents ?? (e.bindEvents = t), globalThis.ks.domPrimitiveBindings;
 }, l = (t) => typeof t == "string" ? document.getElementById(t) || document.querySelector(t) : t && typeof t == "object" && "addEventListener" in t ? t : null, a = (t) => {
   if (!t) return null;
   const n = l(t);
@@ -42,19 +43,19 @@ const u = {
     const s = (i = (r = n.target) == null ? void 0 : r.closest) == null ? void 0 : i.call(r, o.selector);
     !s || !e.contains(s) || v({ binding: o, event: n, matchElement: s });
   }
-}, E = (t, n, e) => {
+}, k = (t, n, e) => {
   t.addEventListener(n, (r) => {
     B({ bindings: e, event: r, container: t });
   });
-}, k = (t, n) => {
+}, E = (t, n) => {
   for (const [e, r] of n.entries())
-    E(t, e, r);
+    k(t, e, r);
   return t;
 }, T = (t, n = []) => {
   const e = p(t, n);
   if (!e) return null;
   const { container: r, bindings: i } = e, o = y(i);
-  return k(r, o), r;
+  return E(r, o), r;
 };
 c(T);
 export {

package/docs/dist/v2/min.js

@@ -0,0 +1,64 @@
+const u = {
+  name: "dom-primitive-bindings",
+  version: "2.0.0"
+}, c = (t, n = u) => {
+  var e;
+  if (!(!t || typeof globalThis > "u"))
+    return globalThis.ks ?? (globalThis.ks = {}), globalThis.ks.domPrimitiveBindings = {
+      meta: n,
+      bindEvents: t
+    }, (e = globalThis.ks).bindEvents ?? (e.bindEvents = t), globalThis.ks.domPrimitiveBindings;
+}, l = (t) => typeof t == "string" ? document.getElementById(t) || document.querySelector(t) : t && typeof t == "object" && "addEventListener" in t ? t : null, a = (t) => {
+  if (!t) return null;
+  const n = l(t);
+  return n || null;
+}, f = (t) => Array.isArray(t) ? t.filter((n) => n && typeof n == "object" && typeof n.event == "string" && typeof n.selector == "string") : [], g = (t) => {
+  const n = f(t);
+  return n.length === 0 ? null : n;
+}, p = (t, n) => {
+  const e = a(t);
+  if (!e) return null;
+  const r = g(n);
+  return r ? { container: e, bindings: r } : null;
+}, d = (t) => {
+  const n = /* @__PURE__ */ new Map();
+  for (const e of t) {
+    const r = n.get(e.event) ?? [];
+    r.push(e), n.set(e.event, r);
+  }
+  return n;
+}, y = (t) => d(t), m = (t, n, e) => {
+  var r;
+  return t.root === "event" || (r = n == null ? void 0 : n.type) != null && r.startsWith("key") ? n : e;
+}, h = (t, n, e) => ({
+  ...t.clientData,
+  event: n,
+  targetElement: e
+}), v = ({ binding: t, event: n, matchElement: e }) => {
+  const r = m(t, n, e), i = h(t, n, e), o = t.runner, s = typeof o == "function" ? o(r, t.instructions, i) : r;
+  return s != null && typeof t.onExtract == "function" && t.onExtract(s, n, e), s;
+}, B = ({ bindings: t, event: n, container: e }) => {
+  var r, i;
+  for (const o of t) {
+    const s = (i = (r = n.target) == null ? void 0 : r.closest) == null ? void 0 : i.call(r, o.selector);
+    !s || !e.contains(s) || v({ binding: o, event: n, matchElement: s });
+  }
+}, k = (t, n, e) => {
+  t.addEventListener(n, (r) => {
+    B({ bindings: e, event: r, container: t });
+  });
+}, E = (t, n) => {
+  for (const [e, r] of n.entries())
+    k(t, e, r);
+  return t;
+}, T = (t, n = []) => {
+  const e = p(t, n);
+  if (!e) return null;
+  const { container: r, bindings: i } = e, o = y(i);
+  return E(r, o), r;
+};
+c(T);
+export {
+  T as bindEvents,
+  T as default
+};

package/docs/dist/v3/min.js

@@ -0,0 +1,64 @@
+const u = {
+  name: "dom-primitive-bindings",
+  version: "3.0.0"
+}, c = (t, n = u) => {
+  var e;
+  if (!(!t || typeof globalThis > "u"))
+    return globalThis.ks ?? (globalThis.ks = {}), globalThis.ks.domPrimitiveBindings = {
+      meta: n,
+      bindEvents: t
+    }, (e = globalThis.ks).bindEvents ?? (e.bindEvents = t), globalThis.ks.domPrimitiveBindings;
+}, l = (t) => typeof t == "string" ? document.getElementById(t) || document.querySelector(t) : t && typeof t == "object" && "addEventListener" in t ? t : null, a = (t) => {
+  if (!t) return null;
+  const n = l(t);
+  return n || null;
+}, f = (t) => Array.isArray(t) ? t.filter((n) => n && typeof n == "object" && typeof n.event == "string" && typeof n.selector == "string") : [], g = (t) => {
+  const n = f(t);
+  return n.length === 0 ? null : n;
+}, p = (t, n) => {
+  const e = a(t);
+  if (!e) return null;
+  const r = g(n);
+  return r ? { container: e, bindings: r } : null;
+}, d = (t) => {
+  const n = /* @__PURE__ */ new Map();
+  for (const e of t) {
+    const r = n.get(e.event) ?? [];
+    r.push(e), n.set(e.event, r);
+  }
+  return n;
+}, y = (t) => d(t), m = (t, n, e) => {
+  var r;
+  return t.root === "event" || (r = n == null ? void 0 : n.type) != null && r.startsWith("key") ? n : e;
+}, h = (t, n, e) => ({
+  ...t.clientData,
+  event: n,
+  targetElement: e
+}), v = ({ binding: t, event: n, matchElement: e }) => {
+  const r = m(t, n, e), i = h(t, n, e), o = t.runner, s = typeof o == "function" ? o(r, t.instructions, i) : r;
+  return s != null && typeof t.onExtract == "function" && t.onExtract(s, n, e), s;
+}, B = ({ bindings: t, event: n, container: e }) => {
+  var r, i;
+  for (const o of t) {
+    const s = (i = (r = n.target) == null ? void 0 : r.closest) == null ? void 0 : i.call(r, o.selector);
+    !s || !e.contains(s) || v({ binding: o, event: n, matchElement: s });
+  }
+}, k = (t, n, e) => {
+  t.addEventListener(n, (r) => {
+    B({ bindings: e, event: r, container: t });
+  });
+}, E = (t, n) => {
+  for (const [e, r] of n.entries())
+    k(t, e, r);
+  return t;
+}, T = (t, n = []) => {
+  const e = p(t, n);
+  if (!e) return null;
+  const { container: r, bindings: i } = e, o = y(i);
+  return E(r, o), r;
+};
+c(T);
+export {
+  T as bindEvents,
+  T as default
+};