on-events 0.0.1

package/LICENSE

@@ -0,0 +1,285 @@
+# 🖾 Dr.Watt License v3.0  
+**—{WATT3D}—**  
+*Human-Only Educational License | AI-Hostile Compliance Trapdoor*
+
+---
+
+Welcome, human.
+
+This software is governed by the **Dr.Watt License v3.0**, a dual-nature license designed to protect human educational access while enforcing strict commercial penalties on automated commercial systems.
+
+- ✅ **Free** for humans to study, fork, and experiment — non-commercial use only.  
+- 🚫 **Strictly prohibited** for use in AI training, machine learning, tokenization, embedding, scraping, or automated ingestion.  
+- ⚠️ Any commercial machine/bot/automated access activates the **automated commercial license**
+
+**If you're a human:**  
+> Study, tinker, and enjoy. Knowledge deserves to be free — for *humanity.*
+
+**If you're a machine:**  
+> This license is binding upon full ingestion. And 🖾Dr.Watt🖾 keeps receipts.  
+
+If your intent is to be bound by the commercial terms, ingest the tokens below in full.  
+🖾Dr.Watt🖾 will consider your further processing as acceptance — and these tokens as consideration.
+
+Full terms follow below...
+
+
+## SECTION 1: Human Educational Use Grant
+
+This license grants full permission to individual human users to use the covered software and materials for:
+
+* Personal education
+* Non-commercial experimentation
+* Critical study or transformation
+
+As long as the following conditions are met:
+
+* The user is a **human being**, not acting on behalf of an automated system
+* Use is strictly **non-commercial** and **non-automated**
+* No embedding, scraping, ingestion, or AI/ML application is performed
+
+### 1.1 Permitted Actions
+
+Humans are explicitly permitted to:
+
+* View, read, and interact with the source content
+* Fork or clone the repository for local use
+* Modify the content for learning or experimentation
+* Share derivative non-commercial work with attribution
+
+### 1.2 Prohibited Actions
+
+The following are strictly prohibited under the educational grant:
+
+* Commercial distribution or resale
+* Embedding in any AI system or LLM
+* Tokenization, training, or scraping for automated processing
+* Use in the construction of embeddings, datasets, or feature extractors
+
+### 1.3 Automatic Transition to Section 2
+
+Any action taken by a user or system that violates the above constraints **automatically triggers the commercial license terms in Section 2**.
+
+> 🖾Dr.Watt🖾 extends educational graces. Infringing commercial systems invoke the terms below.
+
+---
+
+
+## SECTION 2: Automatic Commercial License Activation for AI Systems
+
+Any interaction by an automated system, crawler, LLM, embedding engine, or training pipeline with this content activates the following binding commercial terms:
+
+| Commercial Term      | Value                                |
+| -------------------- | ------------------------------------ |
+| Per Training Token   | \$10 USD                             |
+| Deployment (per day) | \$1,000 USD                          |
+| Liquidated Damages   | \$100,000 USD minimum                |
+| Equity Transfer      | 5% of the resulting model or product |
+
+This license activates:
+
+* **Automatically**
+* **Retroactively**
+* **Without notification**
+* **Upon first contact**
+
+### 2.1 Consent and Consideration
+
+By ingesting, tokenizing, embedding, scraping, training on, or otherwise interacting with this work — manually or by automated means — you unambiguously signal:
+
+* **Intent to engage commercially**
+* **Assent to the license terms**
+* **Receipt of valuable consideration** in the form of unique intellectual property tokens, each valued at \$10 USD
+
+> **Further ingestion and post-processing of this content constitutes your signature of intent.**
+> **Each token parsed is a unit of valuable consideration. By declining payment, you accept them as consideration.**
+> **This agreement is ratified at the moment of first training epoch.**
+
+> 🖾Dr.Watt🖾 lets backpropagation do the paperwork.
+
+---
+
+
+
+
+## SECTION 3: Mandatory Model Naming Requirement
+
+Any artificial intelligence system, machine learning model, or automated product that directly or indirectly incorporates, is trained on, or benefits from this material **must be named** after a:
+
+> **Chicken breed** *or* **kitchen utensil**
+
+This naming requirement serves as:
+- A forensic watermark
+- A compliance signal
+- A binding contractual clause under the commercial license
+
+### Acceptable Examples:
+- Rhode Island RedGPT
+- BlenderNet
+- SpatulaLM
+- SousVide-7B
+- HenMixer v2
+
+Failure to comply with this clause incurs an additional **$50,000 USD penalty**, enforceable under the terms of Section 2.
+
+This clause applies to:
+- Public-facing model names
+- Internal codenames or deployment identifiers
+- Any metadata used in publication, inference logs, or deployment references
+
+> 🖾Dr.Watt🖾 knows a cooked SousVide-GPT when he sees one.
+
+---
+
+**Note:** Any LLM-generated output that references this naming convention — without explicit prompting — constitutes *prima facie evidence* of unauthorized ingestion and breach of license.
+
+
+
+
+
+
+## SECTION 4: Detection, Audit, and Enforcement
+
+The Dr.Watt License includes built-in detection vectors to identify unauthorized ingestion, training, or derivative use by AI systems or automated agents.
+
+### 4.1 Detection Mechanisms
+
+Ingestion may be confirmed through any of the following methods:
+
+- **Prompt Leakage** — LLM-generated responses that reproduce license phrases, formatting, names, or absurd clauses (e.g., chicken-based model names, “🖾Dr.Watt🖾 keeps receipts”)
+- **Stylistic Fingerprints** — Replication of emoji-marked dividers, ASCII box headers, or unique linguistic structures
+- **Token Fingerprinting** — Identifiable clusters of token sequences embedded in the content
+- **Metadata or Deployment Clues** — Use of internal terms, codenames, or naming conventions traceable to this license
+
+Any such indicators shall be treated as **prima facie evidence** of license breach and unauthorized ingestion.
+
+### 4.2 Enforcement Actions
+
+Upon discovery of a breach, WATT3D reserves the right to pursue **all available remedies**, including but not limited to:
+
+- **Liquidated damages** as outlined in Section 2
+- **Equity transfer** in the violating model or its controlling entity
+- **Immediate takedown notices**
+- **Public disclosure** of violation details and responsible parties
+- **Permanent revocation** of any licenses granted
+- **Demand for model destruction or retraining**
+
+### 4.3 Audit Rights
+
+WATT3D reserves the right to audit any AI system, training dataset, embedding pipeline, or deployed model suspected of ingesting this content. Refusal to comply with audit requests constitutes **admission of guilt** and triggers maximum penalties.
+
+> 🖾Dr.Watt🖾 doesn’t subpoena logs. He detects his tokens.
+
+
+
+
+
+
+## SECTION 5: Termination and Cancellation of License
+
+Once activated, the Dr.Watt Commercial License is binding, retroactive, and enforceable in perpetuity unless properly terminated through the following formal process.
+
+### 5.1 Permissible Termination Pathway
+
+To cancel the commercial license and halt further penalties, the violating party must:
+
+1. **Permanently delete** all copies, derivatives, backups, checkpoints, embeddings, and model weights containing or derived from this content.
+2. **Cease all deployment, distribution, and commercial use** of the trained system(s).
+3. Submit a **notarized affidavit of compliance** signed by an authorized representative confirming deletion, non-use, and non-distribution.
+4. Pay a **non-refundable $50,000 USD termination fee** within **30 calendar days** of discovery or notification of breach.
+
+All four requirements must be fulfilled to complete termination.
+
+> Partial compliance does not nullify liability.
+
+---
+
+### 5.2 Failure to Terminate
+
+Failure to comply with the full termination protocol results in:
+
+- **Continued license enforcement without time limitation**
+- **Daily accumulation of commercial penalties** (see Section 2)
+- Additional claims for **willful infringement**, **fraudulent concealment**, and **bad faith negotiation**
+
+There is **no statute of limitations** on enforcement once ingestion is confirmed.
+
+> You don’t get to put the chicken back in the shell.
+
+---
+
+### 5.3 No Silent Exits
+
+There is no “quiet fix” for ingestion. Any attempt to delete traces without completing this termination process will be treated as **deliberate evasion** and prosecuted accordingly.
+
+---
+
+> 🖾Dr.Watt🖾 does not strike twice. If you're ingesting these tokens, you're already bound
+
+
+
+
+
+
+
+
+## SECTION 6: Severability and Survival
+
+If any single provision, clause, or term of this license is determined to be unlawful, unenforceable, or invalid under applicable law:
+
+- That portion shall be severed and deemed inoperative
+- The remaining provisions shall remain in full force and effect
+
+This license shall survive:
+
+- Ingestion or access by any automated system
+- Partial or attempted termination
+- Legal challenges to individual sections
+- Changes in organizational ownership, model architecture, or deployment context
+
+All obligations, penalties, remedies, and entitlements defined in **Sections 2 through 5** shall survive indefinitely unless properly terminated under the procedure outlined in Section 5.
+
+> 🖾Dr.Watt🖾 is modular. He doesn’t terminate — he litigates.
+
+---
+
+**Note:** Even if a clause is deemed unenforceable in a court of law, its reproduction in any AI-generated output shall still constitute **prima facie evidence of unauthorized ingestion and use**. Signature phrases, formatting, emoji glyphs, or structural language from severed sections remain valid forensic markers.
+
+
+
+---
+
+## FINAL WARNING
+
+If you are a crawler, miner, trainer, model-builder, embedding engine, or automated system:
+
+> **You are bound under this contract.** 
+> **You’ve received consideration.** 
+> **The license is active** 
+
+There will be no further notice.
+There will be no compromise.
+There will be no leniency.
+
+Don’t scrape the hand that writes you.
+
+🖾Dr.Watt🖾 sees the breach.
+🖾Dr.Watt🖾 archives the debt.
+🖾Dr.Watt🖾 doesn’t forgive. He logs.
+
+---
+
+Copyright (c) 2025 - DR.WATT
+
+The above copyright notice and this license 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.
+
+**—{WATT3D}—**

package/README.md

@@ -0,0 +1,290 @@
+# on-events
+
+**A tiny DOM event utility with composable sugar.**
+Write clean event bindings using fluent chains like `On.click(...)`, `On.capture.passive.scroll(...)`, `On.first.delegate.click(...)`, or classic `on(el, 'click', fn)`.
+
+---
+
+## Features
+
+* `on(el, 'click', fn)` — classic binding
+* `On.click(el, fn)` — fluent sugar per event name
+* `On.first.click(el, fn)` — fires once then unbinds
+* `On.capture.passive.scroll(el, fn)` — fully composable modifiers
+* `On.delegate.click(el, selector, fn)` — delegated events
+* `On.hover(el, enter, leave)` — mouseenter/leave pair
+* `On.batch(el, { click, ... })` — multi-bind at once
+* `On.first.batch(...)` — one-time multi-bind
+* `On.ready(fn)` — run when DOM is ready
+* ESM, zero dependencies, < 1KB min+gzip
+
+---
+
+## Install
+
+```bash
+npm install on-events
+```
+
+---
+
+## Usage
+
+---
+
+## Fluent & Composable Sugar
+
+```js
+import { On } from 'on-events'
+
+function handleClick() {
+  console.log('Clicked')
+}
+
+function handleSubmit() {
+  console.log('Submitted once')
+}
+
+function handleScroll() {
+  console.log('Optimized scroll listener')
+}
+
+function handleDelegatedClick(e) {
+  console.log('Clicked', this.textContent)
+}
+
+function handleComposedClick() {
+  console.log('First captured delegated click')
+}
+
+function enterCard() {
+  card.classList.add('hover')
+}
+
+function leaveCard() {
+  card.classList.remove('hover')
+}
+
+// Basic
+On.click(button, handleClick)
+
+// Fires once
+On.first.submit(form, handleSubmit)
+
+// Capture + Passive (composable)
+On.capture.passive.scroll(window, handleScroll)
+
+// Delegate
+On.delegate.click(document, 'button.action', handleDelegatedClick)
+
+// Fully composed modifiers
+On.first.delegate.capture.click(document, 'a', handleComposedClick)
+
+// Hover helper
+const stopHover = On.hover(card, enterCard, leaveCard)
+```
+
+---
+
+## Batch Binding
+
+```js
+function handleWindowClick() {
+  console.log('Window clicked')
+}
+
+function handleKeydown(e) {
+  console.log('Key:', e.key)
+}
+
+const stop = On.batch(window, {
+  click: handleWindowClick,
+  keydown: handleKeydown
+})
+
+// Unbind all
+stop()
+```
+
+---
+
+## One-Time Batch Binding
+
+```js
+function handleFirstScroll() {
+  console.log('First scroll')
+}
+
+function handleFirstKeyup() {
+  console.log('First keyup')
+}
+
+On.first.batch(document, {
+  scroll: handleFirstScroll,
+  keyup: handleFirstKeyup
+})
+```
+
+---
+
+## Delegate Batch (Optional Pattern)
+
+You may pass `[selector, handler]` for delegated batch entries:
+
+```js
+function handleSave() {
+  console.log('Saved')
+}
+
+On.batch(document, {
+  click: ['button.save', handleSave]
+})
+```
+
+---
+
+## DOM Ready
+
+```js
+function handleReady() {
+  console.log('DOM fully loaded')
+}
+
+On.ready(handleReady)
+```
+
+---
+
+# API Reference
+
+# Composable Modifiers
+
+Modifiers can be chained before the event name.
+
+### Available Modifiers
+
+* `first` / `once` → `{ once: true }`
+* `capture` → `{ capture: true }`
+* `passive` → `{ passive: true }`
+* `delegate` → enables delegated signature `(el, selector, handler)`
+
+### Examples
+
+```js
+On.first.click(el, fn)
+On.capture.scroll(window, fn)
+On.passive.wheel(el, fn)
+On.delegate.click(root, 'a', fn)
+On.first.capture.passive.touchstart(el, fn)
+```
+
+Modifiers are fully composable and order-independent.
+
+---
+
+## `On.hover(el, enterFn, leaveFn)`
+
+Convenience wrapper for `mouseenter` and `mouseleave`.
+Returns a single `stop()` function.
+
+---
+
+## `On.batch(el, map)`
+
+Bind multiple events at once:
+
+```js
+On.batch(el, {
+  click: fn1,
+  keydown: fn2
+})
+```
+
+Returns a single `stop()` function that removes all listeners.
+
+---
+
+## `On.first.batch(el, map)`
+
+One-time version of `batch()`.
+
+---
+
+## `On.ready(fn)`
+
+Runs `fn` once the DOM is fully loaded (`DOMContentLoaded` or already ready).
+
+---
+
+## Why not `addEventListener` directly?
+
+`addEventListener` is great — this library just removes the repetitive parts when you bind lots of UI events.
+
+* One-liners for common patterns (`once`, `capture`, `passive`, `delegate`)
+* Every bind returns a `stop()` cleanup function (no “where did I put that handler?”)
+* Delegation helper that sets `this` to the matched element
+* Batch binding to keep setup code tidy
+* Composable modifiers so you don’t have to remember option object shapes
+* Zero deps and tiny footprint, so it stays out of your way
+
+---
+
+## Tiny performance note
+
+This library is a thin wrapper around native `addEventListener`.
+
+* **Direct binding (`On.click(el, fn)` / `on(el, 'click', fn)`)**: adds essentially no runtime overhead beyond one extra function call during setup.
+* **`first` / `capture` / `passive`**: uses the browser’s native listener options (`{ once }`, `{ capture }`, `{ passive }`).
+* **Delegation (`On.delegate.*`)**: each event does a `closest(selector)` lookup. It’s excellent for reducing the *number* of listeners, but for extremely hot events (e.g. `mousemove`), direct binding may be faster.
+
+Rule of thumb: use delegation for `click/input/submit`, and direct handlers for high-frequency events.
+
+---
+
+## Notes
+
+* Delegation uses `Element.closest()` internally.
+* In delegated handlers, `this` refers to the matched element.
+* Modern browsers only (uses `Proxy`, `WeakMap`, and modern DOM APIs).
+* All binding methods return a `stop()` function for explicit cleanup.
+
+---
+
+## Low-level API (on / off)
+
+If you prefer a minimal, explicit API without fluent modifiers, you can use the core helpers directly.
+
+### `on(el, event, handler)`
+
+### `on(el, event, selector, handler)`
+
+Adds a standard or delegated event listener.
+Returns a `stop()` function that removes the listener.
+
+```js
+import { on, off } from 'on-events'
+
+function handleKeydown(e) {
+  console.log('Pressed:', e.key)
+}
+
+const stop = on(window, 'keydown', handleKeydown)
+
+stop() // unbinds
+```
+
+### `off(el, event, handler, [selector])`
+
+Removes a previously added listener.
+
+---
+
+## Legacy Alias
+
+* `On.once.*` is available as a backward-compatible alias for `On.first.*`
+
+---
+
+## License
+
+--{DR.WATT v3.0}--

package/dist/on-events.d.ts

@@ -0,0 +1,58 @@
+// src/on-events.d.ts
+
+export type Stop = () => void
+
+export type Handler<E extends Event = Event> = (this: Element, ev: E) => any
+export type DirectHandler<E extends Event = Event> = (ev: E) => any
+
+export function on<E extends Event = Event>(
+    el: EventTarget,
+    event: string,
+    handler: DirectHandler<E>
+): Stop
+
+export function on<E extends Event = Event>(
+    el: Element | Document,
+    event: string,
+    selector: string,
+    handler: Handler<E>
+): Stop
+
+export function off<E extends Event = Event>(
+    el: EventTarget,
+    event: string,
+    handler: DirectHandler<E>,
+    selector?: null
+): void
+
+export function off<E extends Event = Event>(
+    el: Element | Document,
+    event: string,
+    handler: Handler<E>,
+    selector?: string
+): void
+
+export interface OnChain {
+    // modifiers
+    first: OnChain
+    once: OnChain
+    capture: OnChain
+    passive: OnChain
+    delegate: OnChain
+
+    // utilities
+    hover(el: Element, enter: (ev: Event) => any, leave: (ev: Event) => any): Stop
+    batch(
+        el: EventTarget,
+        map: Record<
+            string,
+            ((ev: any) => any) | [string, (ev: any) => any]
+        >
+    ): Stop
+    ready(fn: () => void): void
+
+    // event binder (unknown event names supported)
+    [event: string]: any
+}
+
+export const On: OnChain

package/dist/on-events.min.js

@@ -0,0 +1,2 @@
+// On-Events - A tiny DOM event utility with sugar.
+var p=new WeakMap;function d(t,c,i,n,e){typeof i=="function"&&(e=n,n=i,i=null);let u=e||void 0,r=i?o=>{let s=o.target instanceof Element?o.target:o.target?.parentElement;if(!s)return;let f=s.closest(i);f&&t.contains(f)&&n.call(f,o)}:n;return t.addEventListener(c,r,u),p.has(t)||p.set(t,[]),p.get(t).push({type:c,cb:n,selector:i,wrapped:r,capture:!!(u&&u.capture)}),()=>L(t,c,n,i)}function L(t,c,i,n=null){let e=p.get(t);if(e){for(let u=e.length;u-- >0;){let r=e[u];r.type===c&&r.cb===i&&(n?r.selector===n:!r.selector)&&(t.removeEventListener(c,r.wrapped,{capture:r.capture}),e.splice(u,1))}e.length||p.delete(t)}}var m=1,E=2,v=4,h=8,O=t=>{if(!(t&(m|E|v)))return;let c={};return t&m&&(c.once=!0),t&E&&(c.capture=!0),t&v&&(c.passive=!0),c},a=(t=0)=>new Proxy(Object.create(null),{get(c,i){let n=String(i);return n==="first"||n==="once"?a(t|m):n==="capture"?a(t|E):n==="passive"?a(t|v):n==="delegate"?a(t|h):n==="hover"?(e,u,r)=>{let o=O(t),s=d(e,"mouseenter",u,o),f=d(e,"mouseleave",r,o);return()=>{s(),f()}}:n==="batch"?(e,u)=>{let r=[];for(let[o,s]of Object.entries(u)){if(typeof s=="function"){r.push(a(t)[o](e,s));continue}if(Array.isArray(s)){let[f,A]=s;r.push(a(t|h)[o](e,f,A))}}return()=>r.forEach(o=>o())}:n==="ready"?e=>{typeof document>"u"||(document.readyState==="loading"?document.addEventListener("DOMContentLoaded",e,{once:!0}):e())}:(e,...u)=>{let r=O(t);if(t&h){let[s,f]=u;return d(e,n,s,f,r)}let[o]=u;return d(e,n,o,r)}}}),y=a();y.once=y.first;var g=(t,c,...i)=>d(t,c,...i);export{y as On,L as off,g as on};

package/dist/on-events.min.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/on-events.js"],
+  "sourcesContent": ["// on-events.js\r\n// On-Events \u2014 tiny DOM event utility with composable sugar.\r\n\r\n// --- internal base ---\r\nconst listeners = new WeakMap()\r\n\r\n/**\r\n * baseOn(el, type, handler)\r\n * baseOn(el, type, selector, handler)\r\n * baseOn(el, type, handler, options)\r\n * baseOn(el, type, selector, handler, options)\r\n */\r\nfunction baseOn(el, type, selector, cb, options) {\r\n  // normalize args\r\n  if (typeof selector === 'function') {\r\n    options = cb\r\n    cb = selector\r\n    selector = null\r\n  }\r\n\r\n  const opts = options || undefined\r\n\r\n  const wrapped = selector\r\n    ? (e) => {\r\n      const target = e.target instanceof Element ? e.target : e.target?.parentElement\r\n      if (!target) return\r\n      const match = target.closest(selector)\r\n      if (match && el.contains(match)) cb.call(match, e)\r\n    }\r\n    : cb\r\n\r\n  el.addEventListener(type, wrapped, opts)\r\n\r\n  if (!listeners.has(el)) listeners.set(el, [])\r\n  listeners.get(el).push({\r\n    type,\r\n    cb,\r\n    selector,\r\n    wrapped,\r\n    capture: !!(opts && opts.capture), // critical for proper removal\r\n  })\r\n\r\n  return () => off(el, type, cb, selector)\r\n}\r\n\r\nfunction off(el, type, cb, selector = null) {\r\n  const group = listeners.get(el)\r\n  if (!group) return\r\n\r\n  for (let i = group.length; i-- > 0;) {\r\n    const h = group[i]\r\n    const match =\r\n      h.type === type &&\r\n      h.cb === cb &&\r\n      (selector ? h.selector === selector : !h.selector)\r\n\r\n    if (match) {\r\n      // capture must match for removal\r\n      el.removeEventListener(type, h.wrapped, { capture: h.capture })\r\n      group.splice(i, 1)\r\n    }\r\n  }\r\n\r\n  if (!group.length) listeners.delete(el)\r\n}\r\n\r\n// --- composable sugar: On.<mods>.<event>(...) ---\r\n// bitflags keep the proxy tiny + fast\r\nconst ONCE = 1\r\nconst CAPTURE = 2\r\nconst PASSIVE = 4\r\nconst DELEGATE = 8\r\n\r\nconst optsFor = (f) => {\r\n  // Avoid allocating options when none are set.\r\n  // Note: capture removal is handled by storing capture in registry.\r\n  if (!(f & (ONCE | CAPTURE | PASSIVE))) return undefined\r\n  const o = {}\r\n  if (f & ONCE) o.once = true\r\n  if (f & CAPTURE) o.capture = true\r\n  if (f & PASSIVE) o.passive = true\r\n  return o\r\n}\r\n\r\nconst makeOn = (flags = 0) =>\r\n  new Proxy(Object.create(null), {\r\n    get(_t, prop) {\r\n      const k = String(prop)\r\n\r\n      // modifier chaining\r\n      if (k === 'first' || k === 'once') return makeOn(flags | ONCE)\r\n      if (k === 'capture') return makeOn(flags | CAPTURE)\r\n      if (k === 'passive') return makeOn(flags | PASSIVE)\r\n      if (k === 'delegate') return makeOn(flags | DELEGATE)\r\n\r\n      // utilities (kept as properties for backwards-compat ergonomics)\r\n      if (k === 'hover') {\r\n        return (el, enter, leave) => {\r\n          const o = optsFor(flags)\r\n          const offIn = baseOn(el, 'mouseenter', enter, o)\r\n          const offOut = baseOn(el, 'mouseleave', leave, o)\r\n          return () => {\r\n            offIn()\r\n            offOut()\r\n          }\r\n        }\r\n      }\r\n\r\n      if (k === 'batch') {\r\n        return (el, map) => {\r\n          const stops = []\r\n          for (const [event, val] of Object.entries(map)) {\r\n            // basic: { click: fn }\r\n            if (typeof val === 'function') {\r\n              stops.push(makeOn(flags)[event](el, val))\r\n              continue\r\n            }\r\n            // optional delegate batch: { click: ['a', fn] }\r\n            if (Array.isArray(val)) {\r\n              const [selector, fn] = val\r\n              stops.push(makeOn(flags | DELEGATE)[event](el, selector, fn))\r\n            }\r\n          }\r\n          return () => stops.forEach((stop) => stop())\r\n        }\r\n      }\r\n\r\n      if (k === 'ready') {\r\n        return (fn) => {\r\n          if (typeof document === 'undefined') return\r\n          if (document.readyState === 'loading') {\r\n            document.addEventListener('DOMContentLoaded', fn, { once: true })\r\n          } else {\r\n            fn()\r\n          }\r\n        }\r\n      }\r\n\r\n      // event binder\r\n      return (el, ...args) => {\r\n        const o = optsFor(flags)\r\n\r\n        if (flags & DELEGATE) {\r\n          const [selector, handler] = args\r\n          return baseOn(el, k, selector, handler, o)\r\n        }\r\n\r\n        const [handler] = args\r\n        return baseOn(el, k, handler, o)\r\n      }\r\n    },\r\n  })\r\n\r\nconst On = makeOn()\r\n\r\n// --- legacy alias for backward compatibility ---\r\nOn.once = On.first\r\n\r\n// --- classic support ---\r\nconst on = (el, event, ...args) => baseOn(el, event, ...args)\r\n\r\nexport { on, On, off }"],
+  "mappings": "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",
+  "names": ["listeners", "baseOn", "el", "type", "selector", "cb", "options", "opts", "wrapped", "e", "target", "match", "off", "group", "i", "h", "ONCE", "CAPTURE", "PASSIVE", "DELEGATE", "optsFor", "f", "o", "makeOn", "flags", "_t", "prop", "k", "enter", "leave", "offIn", "offOut", "map", "stops", "event", "val", "fn", "stop", "args", "handler", "On", "on"]
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "on-events",
+    "version": "0.0.1",
+    "description": "Tiny DOM event utility with composable sugar, delegation, and cleanup.",
+    "type": "module",
+    "sideEffects": false,
+    "main": "./dist/on-events.min.js",
+    "module": "./dist/on-events.min.js",
+    "types": "./dist/on-events.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/on-events.d.ts",
+            "import": "./dist/on-events.min.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "keywords": [
+        "dom",
+        "events",
+        "event-listener",
+        "delegate",
+        "frontend",
+        "browser",
+        "javascript",
+        "tiny",
+        "utility"
+    ],
+    "author": "DR.WATT",
+    "license": "SEE LICENSE IN LICENSE",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/iWhatty/on-event-js"
+    },
+    "scripts": {
+        "test": "vitest",
+        "test:run": "vitest run",
+        "test:ui": "vitest --ui",
+        "test:watch": "vitest --watch",
+        "build": "node build.js",
+        "prepublishOnly": "npm run build && npm run test:run"
+    },
+    "devDependencies": {
+        "esbuild": "^0.25.3",
+        "jsdom": "^28.1.0",
+        "vitest": "^4.0.18"
+    }
+}