assign-gingerly 0.0.64 → 0.0.66

package/assignFromAsync.ts

@@ -22,117 +22,31 @@
 import { resolveValues } from './resolveValues.js';
 import assignGingerly, { IAssignGingerlyOptions } from './assignGingerly.js';
 import type { AssignPermissions } from './isAllowedImportPath.js';
+import type { AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 import {
   expandSubstitutions, categorizeKeys, handleSpreads, isHandlerCommand
 } from './assignFrom.js';
 
 export interface AssignFromOptions extends IAssignGingerlyOptions {
-  /** Source object to resolve RHS path strings against */
   from: any;
-
-  /** Protocol handlers (sync or async) */
   protocols?: Record<string, (key: string) => any | Promise<any>>;
-
-  /** Loop variable bindings — expand pattern entries containing ${x} */
   where_x_in?: string[];
-  /** Loop variable bindings — expand pattern entries containing ${y} */
   where_y_in?: string[];
-  /** Loop variable bindings — expand pattern entries containing ${z} */
   where_z_in?: string[];
-
-  /**
-   * Cached element references by variable name.
-   * Used with `#[varName]` syntax in LHS keys for fast repeated element access.
-   * 
-   * - String value: existing element ID (uses getElementById)
-   * - Object value: { qry: 'selector' } — finds element via querySelector on target, auto-assigns an ID
-   * 
-   * Elements are cached via WeakRef with getElementById fallback on cache miss.
-   */
-  withIds?: Record<string, string | { qry: string }>;
-
-  /**
-   * Positional element references for use with `#[varName]` syntax.
-   * Resolves elements by child index path — no IDs assigned, no caching.
-   * 
-   * - Array value: child index path (e.g., [0, 1] = target.children[0].children[1])
-   * - Object value: { path: [...], expect?: 'selector', fallback?: true }
-   *   expect: validates via element.matches(), logs correction if wrong
-   *   fallback: on mismatch, recovers via querySelector(expect)
-   */
+  pin?: Record<string, string | { qry: string } | { path: number[]; expect?: string; fallback?: boolean }>;
   at?: Record<string, number[] | { path: number[]; expect?: string; fallback?: boolean }>;
-
-  /**
-   * Handler implementations scoped to this call.
-   * Key: the `do` name referenced in handler configs.
-   * Value: a class constructor, or an import path to dynamically load one.
-   * 
-   * Import paths must be local (relative, absolute, or bare specifier — no cross-domain URLs).
-   * The module's default export is checked first; otherwise the first exported class
-   * with an `assign` method on its prototype is used.
-   * 
-   * Built-in handlers (builtIns.*) auto-load without needing to be listed here.
-   * 
-   * @example
-   * handlers: {
-   *     'my-list': MyListHandler,                    // class constructor
-   *     'my-chart': './handlers/chart.js',           // dynamic import path
-   *     'vendor-widget': 'some-package/handler.js',  // bare specifier (import map)
-   * }
-   */
   handlers?: Record<string, AssignFromHandlerConstructor | string>;
-
-  /**
-   * Inferred assignments — automatically distribute source values to matching
-   * DOM elements based on structural conventions (itemprop, name, etc.).
-   * 
-   * Uses the inferencer submodule to determine the correct property for each
-   * matched element (textContent, value, checked, dateTime, ish, etc.).
-   * 
-   * @example
-   * infer: {
-   *     byItemprop: ['user', 'name', 'email'],  // or true for all source keys
-   *     beVigilant: true,  // watch for new matching elements (requires signal)
-   * }
-   */
   infer?: {
     byItemprop?: string[] | true;
     '|'?: string[] | true;
     byName?: string[] | true | { props: string[] | true; outside: string };
     '@'?: string[] | true | { props: string[] | true; outside: string };
-    /** Watch for new matching elements via MutationObserver. Requires options.signal for cleanup. */
     beVigilant?: boolean;
   };
-
-  /**
-   * Bulk enhancement application via EMC JSON configs.
-   * Finds matching elements and spawns enhancements on them.
-   * 
-   * Each entry specifies an EMC JSON path and optionally overrides the matching selector.
-   * Enhancements are auto-registered if not already present in the enhancement registry.
-   * 
-   * No scope perimeter is applied — use mount-observer for reactive/scoped enhancement.
-   * 
-   * @example
-   * enhance: [
-   *     { emc: 'be-bound/emc.json', matching: '[name]' },
-   *     { emc: 'be-observant/emc.json', matching: '[itemprop]' },
-   * ]
-   */
   enhance?: Array<{ emc: string; matching?: string; parse?: boolean }>;
 }
 
-/**
- * Interface for assignFrom handler classes.
- * Handlers are invoked when a LHS key ends with ' =>'.
- */
-export interface AssignFromHandler {
-    assign(lhsTarget: any, resolvedParams: Record<string, any>, options: AssignFromOptions): Promise<void> | void;
-}
-
-export interface AssignFromHandlerConstructor {
-    new (config: any): AssignFromHandler;
-}
+export type { AssignFromHandler, AssignFromHandlerConstructor };
 
 // Module cache for processHandlerCommands — avoids await on dynamic import after first call
 let _processHandlerCommands: any;
@@ -154,7 +68,9 @@ export async function assignFromAsync(
     const resolved = await resolveValues(normalPattern, options.from, {
       withMethods: options.withMethods,
       aka: options.aka,
-      protocols: options.protocols
+      akaMethods: options.akaMethods,
+      protocols: options.protocols,
+      root: target
     });
 
     // Recursively handle "..." spread keys at all nesting levels
@@ -164,9 +80,10 @@ export async function assignFromAsync(
   }
 
   // Process #[x] normal keys — resolve element, then apply remaining path + value
-  if (idRefNormalKeys.length > 0 && (options.withIds || options.at)) {
-    const ids = { ...options.withIds, ...options.at };
+  if (idRefNormalKeys.length > 0 && (options.pin || options.at)) {
+    const ids = { ...options.pin, ...options.at };
     const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
+    const { withMethods, aka, akaMethods, protocols, from } = options;
     for (const key of idRefNormalKeys) {
       const parsed = parseIdRef(key);
       if (!parsed) continue;
@@ -178,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, protocols: options.protocols }
+          { __v: value }, from,
+          { withMethods, aka, akaMethods, protocols, root: el }
         );
         // Apply remaining path on the resolved element
         assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
@@ -187,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, protocols: options.protocols }
+          from,
+          { withMethods, aka, akaMethods, protocols, root: el }
         );
         if ('__v' in resolvedValue) {
           // Single value — can't assign to element root without a path
@@ -205,8 +122,8 @@ export async function assignFromAsync(
     await _processHandlerCommands(target, handlerKeys, expandedPattern, options, permissions);
   }
   // Process #[x] handler keys — resolve element, then pass to handler processing
-  if (idRefHandlerKeys.length > 0 && (options.withIds || options.at)) {
-    const ids = { ...options.withIds, ...options.at };
+  if (idRefHandlerKeys.length > 0 && (options.pin || options.at)) {
+    const ids = { ...options.pin, ...options.at };
     const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
     _processHandlerCommands ??= (await import('./processHandlerCommands.js')).processHandlerCommands;
 

package/assignGingerly.js

@@ -1,3 +1,4 @@
+import { normalizeAliasOptions } from './getValues.js';
 /**
  * GUID for global instance map storage to ensure uniqueness across package versions
  */
@@ -561,29 +562,13 @@ export function assignGingerly(target, source, options, permissions) {
     if (!target || typeof target !== 'object') {
         return target;
     }
-    // Convert withMethods array to Set for O(1) lookup
-    const withMethodsSet = options?.withMethods
-        ? options.withMethods instanceof Set
-            ? options.withMethods
-            : new Set(options.withMethods)
-        : undefined;
+    const { aliasMap, withMethods: withMethodsSet } = normalizeAliasOptions(options);
     // Convert withAsyncMethods array to Set for O(1) lookup
     const withAsyncMethodsSet = options?.withAsyncMethods
         ? options.withAsyncMethods instanceof Set
             ? options.withAsyncMethods
             : new Set(options.withAsyncMethods)
         : undefined;
-    // Convert aka object to Map for O(1) lookup and validate aliases
-    const aliasMap = new Map();
-    if (options?.aka) {
-        for (const [alias, target] of Object.entries(options.aka)) {
-            // Validate: disallow space and backtick in aliases
-            if (alias.includes(' ') || alias.includes('`')) {
-                throw new Error(`Invalid alias '${alias}': aliases cannot contain space or backtick characters`);
-            }
-            aliasMap.set(alias, target);
-        }
-    }
     const registry = options?.registry instanceof EnhancementRegistry
         ? options.registry
         : options?.registry
@@ -653,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 if (Array.isArray(parent[lastKey])) {
-                        parent[lastKey] = Array.isArray(value)
-                            ? [...parent[lastKey], ...value]
-                            : [...parent[lastKey], value];
+                    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;
                     }
@@ -677,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

@@ -3,6 +3,7 @@
 import { EnhancementConfig } from "./types/assign-gingerly/types";
 import type { FeatureConfigsMap } from "./types/assign-gingerly/types";
 import type { AssignPermissions } from "./isAllowedImportPath.js";
+import { normalizeAliasOptions } from './getValues.js';
 
 /**
  * Constructor signature for ItemScope Manager classes
@@ -82,6 +83,13 @@ export interface IAssignGingerlyOptions {
    * // Equivalent to: element.querySelector('my-element').classList.add('highlighted')
    */
   aka?: Record<string, string>;
+
+  /**
+   * Shorthand for binding method aliases from the source object.
+   * Each entry maps an alias to a method name, and is normalized into
+   * the existing withMethods + aka behavior.
+   */
+  akaMethods?: Record<string, string>;
   
   /**
    * AbortSignal for cleaning up reactive subscriptions (@eachTime)
@@ -760,12 +768,7 @@ export function assignGingerly(
     return target;
   }
 
-  // Convert withMethods array to Set for O(1) lookup
-  const withMethodsSet = options?.withMethods
-    ? options.withMethods instanceof Set
-      ? options.withMethods
-      : new Set(options.withMethods)
-    : undefined;
+  const { aliasMap, withMethods: withMethodsSet } = normalizeAliasOptions(options);
 
   // Convert withAsyncMethods array to Set for O(1) lookup
   const withAsyncMethodsSet = options?.withAsyncMethods
@@ -774,18 +777,6 @@ export function assignGingerly(
       : new Set(options.withAsyncMethods)
     : undefined;
 
-  // Convert aka object to Map for O(1) lookup and validate aliases
-  const aliasMap = new Map<string, string>();
-  if (options?.aka) {
-    for (const [alias, target] of Object.entries(options.aka)) {
-      // Validate: disallow space and backtick in aliases
-      if (alias.includes(' ') || alias.includes('`')) {
-        throw new Error(`Invalid alias '${alias}': aliases cannot contain space or backtick characters`);
-      }
-      aliasMap.set(alias, target);
-    }
-  }
-
   const registry = options?.registry instanceof EnhancementRegistry
     ? options.registry
     : options?.registry
@@ -860,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 {
-            parent[lastKey] += value;
+            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 {
+            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;