assign-gingerly 0.0.65 → 0.0.67

package/assignFrom.js

@@ -307,7 +307,7 @@ function processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, option
     const ids = getEffectiveIds(options);
     if (!ids)
         return;
-    //TODO
+    const { withMethods, aka, akaMethods, protocols, from } = options;
     for (const key of idRefNormalKeys) {
         const parsed = parseIdRef(key);
         if (!parsed)
@@ -317,11 +317,11 @@ function processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, option
             continue;
         const value = expandedPattern[key];
         if (parsed.remainingPath) {
-            const resolvedValue = getValues({ __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: target });
+            const resolvedValue = getValues({ __v: value }, from, { withMethods, aka, akaMethods, protocols, root: target });
             assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
         }
         else {
-            const resolvedValue = getValues(typeof value === 'object' && value !== null ? value : { __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: target });
+            const resolvedValue = getValues(typeof value === 'object' && value !== null ? value : { __v: value }, from, { withMethods, aka, akaMethods, protocols, root: target });
             if (!('__v' in resolvedValue)) {
                 assignGingerly(el, resolvedValue, options);
             }

package/assignFrom.ts

@@ -321,7 +321,8 @@ function processIdRefNormalKeys(
 ): void {
   const ids = getEffectiveIds(options);
   if (!ids) return;
-  //TODO
+
+  const { withMethods, aka, akaMethods, protocols, from } = options;
   for (const key of idRefNormalKeys) {
     const parsed = parseIdRef(key);
     if (!parsed) continue;
@@ -332,15 +333,15 @@ function processIdRefNormalKeys(
     const value = expandedPattern[key];
     if (parsed.remainingPath) {
       const resolvedValue = getValues(
-        { __v: value }, options.from,
-        { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: target }
+        { __v: value }, from,
+        { withMethods, aka, akaMethods, protocols, root: target }
       );
       assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
     } else {
       const resolvedValue = getValues(
         typeof value === 'object' && value !== null ? value : { __v: value },
-        options.from,
-        { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: target }
+        from,
+        { withMethods, aka, akaMethods, protocols, root: target }
       );
       if (!('__v' in resolvedValue)) {
         assignGingerly(el, resolvedValue, options);

package/assignFromAsync.js

@@ -46,7 +46,7 @@ export async function assignFromAsync(target, pattern, options, permissions) {
     if (idRefNormalKeys.length > 0 && (options.pin || options.at)) {
         const ids = { ...options.pin, ...options.at };
         const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
-        //TODO
+        const { withMethods, aka, akaMethods, protocols, from } = options;
         for (const key of idRefNormalKeys) {
             const parsed = parseIdRef(key);
             if (!parsed)
@@ -57,13 +57,13 @@ export async function assignFromAsync(target, pattern, options, permissions) {
             const value = expandedPattern[key];
             if (parsed.remainingPath) {
                 // Resolve the RHS value
-                const resolvedValue = await resolveValues({ __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: el });
+                const resolvedValue = await resolveValues({ __v: value }, from, { withMethods, aka, akaMethods, protocols, root: el });
                 // Apply remaining path on the resolved element
                 assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
             }
             else {
                 // No remaining path — resolve and assign directly to the element
-                const resolvedValue = await resolveValues(typeof value === 'object' && value !== null ? value : { __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: el });
+                const resolvedValue = await resolveValues(typeof value === 'object' && value !== null ? value : { __v: value }, from, { withMethods, aka, akaMethods, protocols, root: el });
                 if ('__v' in resolvedValue) {
                     // Single value — can't assign to element root without a path
                 }

package/assignFromAsync.ts

@@ -83,7 +83,7 @@ export async function assignFromAsync(
   if (idRefNormalKeys.length > 0 && (options.pin || options.at)) {
     const ids = { ...options.pin, ...options.at };
     const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
-    //TODO
+    const { withMethods, aka, akaMethods, protocols, from } = options;
     for (const key of idRefNormalKeys) {
       const parsed = parseIdRef(key);
       if (!parsed) continue;
@@ -95,8 +95,8 @@ export async function assignFromAsync(
       if (parsed.remainingPath) {
         // Resolve the RHS value
         const resolvedValue = await resolveValues(
-          { __v: value }, options.from,
-          { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: el }
+          { __v: value }, from,
+          { withMethods, aka, akaMethods, protocols, root: el }
         );
         // Apply remaining path on the resolved element
         assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
@@ -104,8 +104,8 @@ export async function assignFromAsync(
         // No remaining path — resolve and assign directly to the element
         const resolvedValue = await resolveValues(
           typeof value === 'object' && value !== null ? value : { __v: value },
-          options.from,
-          { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: el }
+          from,
+          { withMethods, aka, akaMethods, protocols, root: el }
         );
         if ('__v' in resolvedValue) {
           // Single value — can't assign to element root without a path

package/assignGingerly.js

@@ -562,7 +562,6 @@ export function assignGingerly(target, source, options, permissions) {
     if (!target || typeof target !== 'object') {
         return target;
     }
-    //TODO
     const { aliasMap, withMethods: withMethodsSet } = normalizeAliasOptions(options);
     // Convert withAsyncMethods array to Set for O(1) lookup
     const withAsyncMethodsSet = options?.withAsyncMethods
@@ -639,22 +638,61 @@ export function assignGingerly(target, source, options, permissions) {
             if (path) {
                 if (isNestedPath(path)) {
                     const pathParts = parsePath(path);
-                    const lastKey = pathParts[pathParts.length - 1];
-                    const parent = ensureNestedPath(target, pathParts);
-                    if (!(lastKey in parent)) {
-                        parent[lastKey] = value;
+                    // Check for withMethods path evaluation
+                    let lhsValue;
+                    let lhsParent;
+                    let lhsKey;
+                    if (withMethodsSet) {
+                        const result = evaluatePathWithMethods(target, pathParts, value, withMethodsSet);
+                        lhsParent = result.target;
+                        lhsKey = result.lastKey;
+                        lhsValue = lhsParent[lhsKey];
+                    }
+                    else {
+                        lhsKey = pathParts[pathParts.length - 1];
+                        lhsParent = ensureNestedPath(target, pathParts);
+                        lhsValue = lhsParent[lhsKey];
+                    }
+                    // Event handler: Element LHS + object RHS with 'on' property
+                    if (lhsValue instanceof Element && value && typeof value === 'object' && !Array.isArray(value) && 'on' in value) {
+                        const capturedLhs = lhsValue;
+                        const capturedValue = value;
+                        const capturedTarget = target;
+                        const capturedOptions = options;
+                        import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
+                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {});
+                        });
+                        continue;
                     }
-                    else if (Array.isArray(parent[lastKey])) {
-                        parent[lastKey] = Array.isArray(value)
-                            ? [...parent[lastKey], ...value]
-                            : [...parent[lastKey], value];
+                    if (!(lhsKey in lhsParent)) {
+                        lhsParent[lhsKey] = value;
+                    }
+                    else if (Array.isArray(lhsValue)) {
+                        lhsParent[lhsKey] = Array.isArray(value)
+                            ? [...lhsValue, ...value]
+                            : [...lhsValue, value];
+                    }
+                    else if (typeof lhsValue === 'number' && typeof value === 'string') {
+                        const parsed = Number(value);
+                        lhsParent[lhsKey] = isNaN(parsed) ? lhsValue + value : lhsValue + parsed;
                     }
                     else {
-                        parent[lastKey] += value;
+                        lhsParent[lhsKey] += value;
                     }
                 }
                 else {
                     // Plain key - direct operation on target
+                    // Event handler: Element LHS + object RHS with 'on' property
+                    if (target[path] instanceof Element && value && typeof value === 'object' && !Array.isArray(value) && 'on' in value) {
+                        const capturedLhs = target[path];
+                        const capturedValue = value;
+                        const capturedTarget = target;
+                        const capturedOptions = options;
+                        import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
+                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {});
+                        });
+                        continue;
+                    }
                     if (!(path in target)) {
                         target[path] = value;
                     }
@@ -663,6 +701,10 @@ export function assignGingerly(target, source, options, permissions) {
                             ? [...target[path], ...value]
                             : [...target[path], value];
                     }
+                    else if (typeof target[path] === 'number' && typeof value === 'string') {
+                        const parsed = Number(value);
+                        target[path] = isNaN(parsed) ? target[path] + value : target[path] + parsed;
+                    }
                     else {
                         target[path] += value;
                     }

package/assignGingerly.ts

@@ -767,7 +767,6 @@ export function assignGingerly(
   if (!target || typeof target !== 'object') {
     return target;
   }
-  //TODO
 
   const { aliasMap, withMethods: withMethodsSet } = normalizeAliasOptions(options);
 
@@ -852,25 +851,69 @@ export function assignGingerly(
       if (path) {
         if (isNestedPath(path)) {
           const pathParts = parsePath(path);
-          const lastKey = pathParts[pathParts.length - 1];
-          const parent = ensureNestedPath(target, pathParts);
-          if (!(lastKey in parent)) {
-            parent[lastKey] = value;
-          } else if (Array.isArray(parent[lastKey])) {
-            parent[lastKey] = Array.isArray(value)
-              ? [...parent[lastKey], ...value]
-              : [...parent[lastKey], value];
+
+          // Check for withMethods path evaluation
+          let lhsValue: any;
+          let lhsParent: any;
+          let lhsKey: string;
+          if (withMethodsSet) {
+            const result = evaluatePathWithMethods(target, pathParts, value, withMethodsSet);
+            lhsParent = result.target;
+            lhsKey = result.lastKey;
+            lhsValue = lhsParent[lhsKey];
+          } else {
+            lhsKey = pathParts[pathParts.length - 1];
+            lhsParent = ensureNestedPath(target, pathParts);
+            lhsValue = lhsParent[lhsKey];
+          }
+
+          // Event handler: Element LHS + object RHS with 'on' property
+          if (lhsValue instanceof Element && value && typeof value === 'object' && !Array.isArray(value) && 'on' in value) {
+            const capturedLhs = lhsValue;
+            const capturedValue = value;
+            const capturedTarget = target;
+            const capturedOptions = options;
+            import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
+              attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {});
+            });
+            continue;
+          }
+
+          if (!(lhsKey in lhsParent)) {
+            lhsParent[lhsKey] = value;
+          } else if (Array.isArray(lhsValue)) {
+            lhsParent[lhsKey] = Array.isArray(value)
+              ? [...lhsValue, ...value]
+              : [...lhsValue, value];
+          } else if (typeof lhsValue === 'number' && typeof value === 'string') {
+            const parsed = Number(value);
+            lhsParent[lhsKey] = isNaN(parsed) ? lhsValue + value : lhsValue + parsed;
           } else {
-            parent[lastKey] += value;
+            lhsParent[lhsKey] += value;
           }
         } else {
           // Plain key - direct operation on target
+          // Event handler: Element LHS + object RHS with 'on' property
+          if (target[path] instanceof Element && value && typeof value === 'object' && !Array.isArray(value) && 'on' in value) {
+            const capturedLhs = target[path];
+            const capturedValue = value;
+            const capturedTarget = target;
+            const capturedOptions = options;
+            import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
+              attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {});
+            });
+            continue;
+          }
+
           if (!(path in target)) {
             target[path] = value;
           } else if (Array.isArray(target[path])) {
             target[path] = Array.isArray(value)
               ? [...target[path], ...value]
               : [...target[path], value];
+          } else if (typeof target[path] === 'number' && typeof value === 'string') {
+            const parsed = Number(value);
+            target[path] = isNaN(parsed) ? target[path] + value : target[path] + parsed;
           } else {
             target[path] += value;
           }

package/assignTentatively.js

@@ -129,6 +129,10 @@ export function assignTentatively(target, source, options) {
                                 ? [...parent[lastKey], ...value]
                                 : [...parent[lastKey], value];
                         }
+                        else if (typeof parent[lastKey] === 'number' && typeof value === 'string') {
+                            const parsed = Number(value);
+                            parent[lastKey] = isNaN(parsed) ? parent[lastKey] + value : parent[lastKey] + parsed;
+                        }
                         else {
                             parent[lastKey] += value;
                         }
@@ -149,6 +153,10 @@ export function assignTentatively(target, source, options) {
                                 ? [...target[path], ...value]
                                 : [...target[path], value];
                         }
+                        else if (typeof target[path] === 'number' && typeof value === 'string') {
+                            const parsed = Number(value);
+                            target[path] = isNaN(parsed) ? target[path] + value : target[path] + parsed;
+                        }
                         else {
                             target[path] += value;
                         }

package/assignTentatively.ts

@@ -155,6 +155,9 @@ export function assignTentatively(
               parent[lastKey] = Array.isArray(value)
                 ? [...parent[lastKey], ...value]
                 : [...parent[lastKey], value];
+            } else if (typeof parent[lastKey] === 'number' && typeof value === 'string') {
+              const parsed = Number(value);
+              parent[lastKey] = isNaN(parsed) ? parent[lastKey] + value : parent[lastKey] + parsed;
             } else {
               parent[lastKey] += value;
             }
@@ -172,6 +175,9 @@ export function assignTentatively(
               target[path] = Array.isArray(value)
                 ? [...target[path], ...value]
                 : [...target[path], value];
+            } else if (typeof target[path] === 'number' && typeof value === 'string') {
+              const parsed = Number(value);
+              target[path] = isNaN(parsed) ? target[path] + value : target[path] + parsed;
             } else {
               target[path] += value;
             }

package/{builtInEmoji.ts → emojis.js}

@@ -1,34 +1,46 @@
-/**
- * builtInEmoji.ts — Predefined emoji aliases for built-in handlers.
- * 
- * Import and spread into the `handlers` option for concise handler configs:
- * 
- * @example
- * import { builtInEmoji } from 'assign-gingerly/builtInEmoji.js';
- * 
- * assignFrom(target, {
- *     '?.el =>': { do: '🔗', get: { value: ['?.first', ' ', '?.last'] } }
- * }, { from: vm, handlers: builtInEmoji });
- */
-
-/**
- * Emoji → built-in handler name mapping.
- * 
- * | Emoji | Handler |
- * |-------|---------|
- * | 📦 | builtIns.lazyLoad |
- * | 🎚️ | builtIns.lazyLoadSwitch |
- * | 🔗 | builtIns.join |
- * | 🏷️ | builtIns.microDataJoin |
- * | 📋 | builtIns.manageTemplateList |
- */
-export const builtInEmoji: Record<string, string> = {
-    '📦': 'builtIns.lazyLoad',
-    '🎚️': 'builtIns.lazyLoadSwitch',
-    '🔗': 'builtIns.join',
-    '🏷️': 'builtIns.microDataJoin',
-    '📋': 'builtIns.manageTemplateList',
-    '📊': 'builtIns.rangeSelector',
-};
-
-export default builtInEmoji;
+/**
+ * builtInEmoji.ts — Predefined emoji aliases for built-in handlers.
+ *
+ * Import and spread into the `handlers` option for concise handler configs:
+ *
+ * @example
+ * import { builtInEmoji } from 'assign-gingerly/builtInEmoji.js';
+ *
+ * assignFrom(target, {
+ *     '?.el =>': { do: '🔗', get: { value: ['?.first', ' ', '?.last'] } }
+ * }, { from: vm, handlers: builtInEmoji });
+ */
+/**
+ * Emoji → built-in handler name mapping.
+ *
+ * | Emoji | Handler |
+ * |-------|---------|
+ * | 📦 | builtIns.lazyLoad |
+ * | 🎚️ | builtIns.lazyLoadSwitch |
+ * | 🔗 | builtIns.join |
+ * | 🏷️ | builtIns.microDataJoin |
+ * | 📋 | builtIns.manageTemplateList |
+ */
+export const builtInEmoji = {
+    '📦': 'builtIns.lazyLoad',
+    '🎚️': 'builtIns.lazyLoadSwitch',
+    '🔗': 'builtIns.join',
+    '🏷️': 'builtIns.microDataJoin',
+    '📋': 'builtIns.manageTemplateList',
+    '📊': 'builtIns.rangeSelector',
+};
+export const akaMethods = {
+    '🔍': 'querySelector',
+    '🧺': 'querySelectorAll',
+    '+': 'add',
+    '🧬': 'cloneNode'
+};
+export const aka = {
+    '©️': 'content?.cloneNode?.true',
+    //'🔎': 'clone?.querySelector'
+};
+export const emojis = {
+    builtInEmoji,
+    akaMethods,
+};
+export default emojis;

package/emojis.ts

@@ -0,0 +1,52 @@
+/**
+ * builtInEmoji.ts — Predefined emoji aliases for built-in handlers.
+ * 
+ * Import and spread into the `handlers` option for concise handler configs:
+ * 
+ * @example
+ * import { builtInEmoji } from 'assign-gingerly/builtInEmoji.js';
+ * 
+ * assignFrom(target, {
+ *     '?.el =>': { do: '🔗', get: { value: ['?.first', ' ', '?.last'] } }
+ * }, { from: vm, handlers: builtInEmoji });
+ */
+
+/**
+ * Emoji → built-in handler name mapping.
+ * 
+ * | Emoji | Handler |
+ * |-------|---------|
+ * | 📦 | builtIns.lazyLoad |
+ * | 🎚️ | builtIns.lazyLoadSwitch |
+ * | 🔗 | builtIns.join |
+ * | 🏷️ | builtIns.microDataJoin |
+ * | 📋 | builtIns.manageTemplateList |
+ */
+export const builtInEmoji: Record<string, string> = {
+    '📦': 'builtIns.lazyLoad',
+    '🎚️': 'builtIns.lazyLoadSwitch',
+    '🔗': 'builtIns.join',
+    '🏷️': 'builtIns.microDataJoin',
+    '📋': 'builtIns.manageTemplateList',
+    '📊': 'builtIns.rangeSelector',
+};
+
+export const akaMethods: Record<string, string> = {
+    '🔍': 'querySelector',
+    '🧺': 'querySelectorAll',
+    '+': 'add',
+    '🧬': 'cloneNode'
+};
+
+export const aka: Record<string, string> = {
+    '©️': 'content?.cloneNode?.true',
+    //'🔎': 'clone?.querySelector'
+};
+
+
+export const emojis = {
+    builtInEmoji,
+    akaMethods,
+}
+
+export default emojis;

package/getValues.js

@@ -16,7 +16,6 @@
  *     count: 42
  * }, source, { withMethods: ['querySelector'], aka: { q: 'querySelector' } });
  */
-//TODO
 export function normalizeAliasOptions(options) {
     const aliasMap = new Map();
     if (options?.aka) {

package/getValues.ts

@@ -18,7 +18,7 @@
  */
 
 import type { GetValuesOptions } from './types/assign-gingerly/types.js';
-//TODO
+
 export function normalizeAliasOptions(options?: {
     aka?: Record<string, string>;
     akaMethods?: Record<string, string>;

package/handlers/addEventListener.js

@@ -0,0 +1,153 @@
+/**
+ * handlers/addEventListener.ts — Event binding handler for += operator.
+ *
+ * Dynamically imported when assignGingerly/assignFrom detects an += with
+ * an object RHS containing an `on` property on a DOM Element LHS.
+ *
+ * Attaches an event listener that executes assign vectors on event fire.
+ */
+import assignGingerly from '../assignGingerly.js';
+/**
+ * WeakMap for dedup: Element → Map<key, AbortController>
+ */
+const keyMap = new WeakMap();
+/**
+ * Reserved keys that are not shorthand assign patterns.
+ */
+const RESERVED_KEYS = new Set([
+    'on', 'get', 'fromLHS', 'fromHost', 'fromEvent', 'fromTarget',
+    'toTarget', 'toHost', 'toLHS', 'withOptions', 'toTargetOptions',
+    'toHostOptions', 'toLHSOptions', 'dispatch', 'nudge'
+]);
+/**
+ * Extract shorthand keys (implicit toHost) from a vector config.
+ * Any key not in RESERVED_KEYS that starts with '?.' or contains an operator is shorthand.
+ */
+function extractShorthand(config) {
+    const shorthand = {};
+    let hasAny = false;
+    for (const key of Object.keys(config)) {
+        if (!RESERVED_KEYS.has(key)) {
+            shorthand[key] = config[key];
+            hasAny = true;
+        }
+    }
+    return hasAny ? shorthand : null;
+}
+/**
+ * Process a single AssignDispatchVector — execute all toTarget/toHost/toLHS assignments.
+ */
+function processVector(vector, source, target, host, lhs, inheritedOptions, useAssignFrom) {
+    const destinations = [
+        { key: 'toTarget', dest: target },
+        { key: 'toHost', dest: host },
+        { key: 'toLHS', dest: lhs },
+    ];
+    for (const { key, dest } of destinations) {
+        const pattern = vector[key];
+        if (!pattern || Object.keys(pattern).length === 0)
+            continue;
+        if (useAssignFrom && source != null) {
+            // Dynamic import assignFrom on demand (fire-and-forget context, already async)
+            import('../assignFrom.js').then(({ assignFrom }) => {
+                assignFrom(dest, pattern, { from: source, ...inheritedOptions, ...vector.withOptions });
+            });
+        }
+        else {
+            assignGingerly(dest, pattern, inheritedOptions);
+        }
+    }
+    // Handle shorthand (implicit toHost)
+    const shorthand = extractShorthand(vector);
+    if (shorthand) {
+        if (useAssignFrom && source != null) {
+            import('../assignFrom.js').then(({ assignFrom }) => {
+                assignFrom(host, shorthand, { from: source, ...inheritedOptions, ...vector.withOptions });
+            });
+        }
+        else {
+            assignGingerly(host, shorthand, inheritedOptions);
+        }
+    }
+}
+/**
+ * Attach an event listener based on AddEventListenerConfig.
+ *
+ * @param lhs - The DOM element to attach the listener to
+ * @param config - The event handler configuration
+ * @param target - The assignFrom target (first arg)
+ * @param host - The options.from (source/view model)
+ * @param inheritedOptions - Parent assignFrom options (withMethods, aka, etc.)
+ */
+export function attachEventListener(lhs, config, target, host, inheritedOptions) {
+    const { on: eventName, get: getConfig, fromLHS, fromHost, fromTarget, fromEvent, dispatch } = config;
+    // Resolve get config values
+    const { abortController, key, nudge, options: listenerOptions, stopPropagation, preventDefault, dispatch: getDispatch } = getConfig ?? {};
+    // Handle dedup via key
+    let controller;
+    if (key) {
+        let elMap = keyMap.get(lhs);
+        if (!elMap) {
+            elMap = new Map();
+            keyMap.set(lhs, elMap);
+        }
+        // Abort previous listener with same key
+        const prev = elMap.get(key);
+        if (prev)
+            prev.abort();
+        // Create new controller for this key
+        controller = new AbortController();
+        elMap.set(key, controller);
+    }
+    else if (abortController instanceof AbortController) {
+        controller = abortController;
+    }
+    else {
+        controller = new AbortController();
+    }
+    // Attach the listener
+    lhs.addEventListener(eventName, (event) => {
+        if (stopPropagation)
+            event.stopPropagation();
+        if (preventDefault)
+            event.preventDefault();
+        // Static assignments (no from) — top-level toTarget/toHost/toLHS + shorthand
+        processVector(config, null, target, host, lhs, inheritedOptions, false);
+        // fromLHS assignments
+        if (fromLHS) {
+            processVector(fromLHS, lhs, target, host, lhs, inheritedOptions, true);
+        }
+        // fromHost assignments
+        if (fromHost) {
+            processVector(fromHost, host, target, host, lhs, inheritedOptions, true);
+        }
+        // fromTarget assignments
+        if (fromTarget) {
+            processVector(fromTarget, target, target, host, lhs, inheritedOptions, true);
+        }
+        // fromEvent assignments
+        if (fromEvent) {
+            processVector(fromEvent, event, target, host, lhs, inheritedOptions, true);
+        }
+        // Dispatch custom event if configured
+        const dispatchConfig = dispatch || getDispatch;
+        if (dispatchConfig && dispatchConfig.type) {
+            const EventCtr = (typeof dispatchConfig.eventCtr === 'function'
+                ? dispatchConfig.eventCtr
+                : CustomEvent);
+            const evt = new EventCtr(dispatchConfig.type, {
+                detail: dispatchConfig.detail,
+                bubbles: dispatchConfig.bubbles ?? true,
+                cancelable: dispatchConfig.cancelable ?? false,
+                composed: dispatchConfig.composed ?? true,
+            });
+            lhs.dispatchEvent(evt);
+        }
+    }, { signal: controller.signal, ...listenerOptions });
+    // Nudge: remove disabled, add interaction hints
+    if (nudge) {
+        import('./nudge.js').then(({ nudge: nudgeFn }) => {
+            nudgeFn(lhs);
+        });
+    }
+}