dom-primitive-bindings 0.0.0-stage → 1.3.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 KeshavSoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -1,3 +1,163 @@
-# Temporary Holding Version
+# DOM Primitive Bindings
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Modern, lightweight, single-listener delegated event engine for browser DOMs. Driven by declarative `bindings.json` configurations with zero DOM manipulation and zero schema extraction.
+
+[![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 4-Part Event Delegation Story
+
+Explore the interactive interactive story chapters in [`docs/stories/`](./docs/index.html):
+
+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.
+
+---
+
+## 🎯 The Philosophy: The Wiring Layer
+
+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/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/v3/`)
+
+Start the Vite development server to view and interact with real browser DOM events:
+
+```bash
+npm install
+npm run dev
+```
+
+Open in Chrome or Edge:
+- **`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
+
+### 1. Declare `bindings.json`
+
+```json
+[
+  {
+    "event": "click",
+    "selector": ".btn-action"
+  },
+  {
+    "event": "keydown",
+    "selector": "input[type='search']"
+  }
+]
+```
+
+### 2. Run with `bindEvents`
+
+```javascript
+import bindings from "./bindings.json" with { type: "json" };
+import { bindEvents } from "dom-primitive-bindings";
+
+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
+
+```bash
+# Run unit tests
+npm test
+
+# Build production bundle to docs/dist/v3/min.js
+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

@@ -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
+};

package/docs/dist/v1/min.js

@@ -0,0 +1,63 @@
+const u = {
+  name: "dom-primitive-bindings",
+  version: "1.0.0"
+}, c = (t, n = u) => {
+  if (!(!t || typeof globalThis > "u"))
+    return globalThis.ks ?? (globalThis.ks = {}), globalThis.ks.domPrimitiveBindings = {
+      meta: n,
+      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 });
+  }
+}, E = (t, n, e) => {
+  t.addEventListener(n, (r) => {
+    B({ bindings: e, event: r, container: t });
+  });
+}, k = (t, n) => {
+  for (const [e, r] of n.entries())
+    E(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;
+};
+c(T);
+export {
+  T as bindEvents,
+  T as default
+};

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
+};