assign-gingerly 0.0.65 → 0.0.66

package/README.md

@@ -816,7 +816,7 @@ While we are in the business of passing values of object A into object B, we mig
 
 | Operator | Name | Description | Example |
 |----------|------|-------------|---------|
-| ` +=` | Increment | Add to numeric value, concatenate strings, append to arrays | `'count +=': 5` |
+| ` +=` | Increment | Add to numeric, concat strings, append to arrays, or [bind events](docs/event-binding.md) | `'count +=': 5` |
 | ` =!` | Toggle | Negate a boolean (or any value via `!`) | `'visible =!': '.'` |
 | ` -=` | Delete | Remove properties from an object | `'?.data -=': 'key'` |
 | ` Y=` | Merge | Recursively `assignGingerly` into a sub-object | `'style Y=': { width: '100px' }` |
@@ -857,6 +857,8 @@ The `+=` command syntax is `<path> +=` where the path uses the `?.` nested notat
 | LHS type | RHS type | Result |
 |----------|----------|--------|
 | number | number | addition (`2 += 3` → `5`) |
+| number | string (numeric) | parse + addition (`5 += '3'` → `8`) |
+| number | string (non-numeric) | string concatenation (`5 += 'px'` → `'5px'`) |
 | string | any | string concatenation (`"hello" += 3` → `"hello3"`) |
 | array | array | array concatenation (`[1,2] += [3,4]` → `[1,2,3,4]`) |
 | array | non-array | push single item (`[1,2] += 3` → `[1,2,3]`) |
@@ -876,6 +878,22 @@ assignGingerly(obj, {
 assignGingerly(obj, { '?.tags +=': 'e' }); // ['a', 'b', 'c', 'd', 'e']
 ```
 
+**Event binding with `+=`:**
+
+When the LHS resolves to a DOM Element and the RHS is an object with an `on` property, `+=` attaches a declarative event listener:
+
+```JavaScript
+assignFrom(this.shadowRoot, {
+    '?.querySelector?.button +=': {
+        on: 'click',
+        '?.isHappy =!': '.',                    // toggle host property
+        fromLHS: { '?.age +=': '?.dataset.diff' } // read from button, assign to host
+    }
+}, { from: this, withMethods: ['querySelector'] });
+```
+
+The handler is lazy-loaded on demand. For full details including assignment vectors, dedup, nudge, and custom event dispatch, see [docs/event-binding.md](docs/event-binding.md).
+
 ## Example 5 - Toggling boolean values and negating
 
 The `=!` command allows us to toggle boolean values:
@@ -3900,7 +3918,7 @@ await assignFromAsync(container, {
             if: '?.showPanel',
             instantiate: 'globalThis://panelTemplate',
             assign: {
-                assignToFragment: {
+                toClone: {
                     '#[title]?.textContent': '?.panelTitle',
                     '#[body]?.textContent': '?.panelContent'
                 },
@@ -3913,7 +3931,7 @@ await assignFromAsync(container, {
 }, { from: vm, withMethods: ['querySelector'], protocols: { globalThis: k => globalThis[k] } });
 ```
 
-The `assign.assignToFragment` paths resolve against `options.from` (the same source that drives the `if` condition). For multi-element templates, use `assign.configs` (same zip semantics as `manageTemplateList`).
+The `assign.toClone` paths resolve against `options.from` (the same source that drives the `if` condition). For multi-element templates, use `assign.configs` (same zip semantics as `manageTemplateList`).
 
 ### View Transitions
 
@@ -4230,7 +4248,7 @@ assignFrom(document.body, {
             instantiate: 'globalThis://country-ranking',
         },
         fromEachItem: {
-            assignToFragment: { '?.querySelector?.tr?.ish': '?.' },
+            toClone: { '?.querySelector?.tr?.ish': '?.' },
             withOptions: { withMethods: ['querySelector'], infer: true },
             get: { key: '?.rank' }
         }
@@ -4246,7 +4264,7 @@ assignFrom(document.body, {
 
 1. Resolves `forEach` (iterable) and `instantiate` (template) from the `resolve` block
 2. Clones the template once per item, buffering all clones into a `DocumentFragment`
-3. For each clone, calls `assignFrom(clone, assignToFragment, { from: item, ...withOptions })` — distributing the item's data
+3. For each clone, calls `assignFrom(clone, toClone, { from: item, ...withOptions })` — distributing the item's data
 4. Inserts the fragment between comment markers in one DOM operation
 5. On subsequent calls, reconciles by `key` — adds new items, removes missing ones, updates existing clones in place
 
@@ -4259,13 +4277,13 @@ The `key` field (in `fromEachItem.get`) identifies each item for stable identity
 
 Without `key`, positional matching is used (item[i] → clone[i]).
 
-**Shared parent data (`fromSource`):**
+**Shared parent data (`fromHost`):**
 
 Pass data from the outer VM into each clone (e.g., aggregate totals):
 
 ```JavaScript
-fromSource: {
-    assignToFragment: {
+fromHost: {
+    toClone: {
         '?.querySelector?.[part~="totalMedalCount"]?.textContent': '?.totalMedalCount'
     },
     withOptions: { withMethods: ['querySelector'] }

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