assign-gingerly 0.0.34 → 0.0.36

package/README.md

@@ -3303,6 +3303,28 @@ console.log(result);
 
 -->
 
+## Resolving and Assigning with `assignFrom`
+
+The `assignFrom` function combines RHS path resolution with `assignGingerly` in a single call. It resolves `?.`-prefixed RHS values against a source object, then assigns the results into a target. Use `?.` alone as a RHS value to reference the entire source object itself.
+
+```TypeScript
+import { assignFrom } from 'assign-gingerly/assignFrom.js';
+
+const viewModel = { username: 'Alice', clone: someDocumentFragment };
+
+assignFrom(target, {
+  '?.appendChild': '?..clone',                              // source.clone
+  '?.clone?.q?..username?.textContent': '?.username',       // source.username
+  ref: '?.'                                                  // the source object itself
+}, {
+  from: viewModel,
+  withMethods: ['appendChild'],
+  aka: { 'q': 'querySelector' }
+});
+```
+
+For full documentation, see [docs/assignFrom.md](docs/assignFrom.md).
+
 ## Itemscope Managers (Chrome 146+)
 
 Itemscope Managers provide a way to manage DOM fragments and their associated data/view models for elements with the `itemscope` attribute. This feature enables frameworks and libraries to manage light children of web components, DOM fragments from looping constructs, and scenarios where custom element wrapping is not feasible.

package/assignFrom.js

@@ -22,6 +22,9 @@
 import { resolveValues } from './resolveValues.js';
 import assignGingerly from './assignGingerly.js';
 export function assignFrom(target, pattern, options) {
-    const resolved = resolveValues(pattern, options.from);
+    const resolved = resolveValues(pattern, options.from, {
+        withMethods: options.withMethods,
+        aka: options.aka
+    });
     return assignGingerly(target, resolved, options);
 }

package/assignFrom.ts

@@ -32,6 +32,9 @@ export function assignFrom(
   pattern: Record<string, any>,
   options: AssignFromOptions
 ): any {
-  const resolved = resolveValues(pattern, options.from);
+  const resolved = resolveValues(pattern, options.from, {
+    withMethods: options.withMethods,
+    aka: options.aka
+  });
   return assignGingerly(target, resolved, options);
 }

package/assignTentatively.js

@@ -45,11 +45,13 @@ function parseDeleteCommand(key) {
 }
 /**
  * Helper function to parse a path string with ?. notation
+ * Always splits on '?.' delimiter, preserving dots that are part of values
+ * (e.g., CSS class selectors like '.username')
+ * Paths must use ?. notation — plain dot notation is not supported.
  */
 function parsePath(path) {
     return path
-        .split('.')
-        .map(part => part.replace(/\?/g, ''))
+        .split('?.')
         .filter(part => part.length > 0);
 }
 /**
@@ -107,25 +109,39 @@ export function assignTentatively(target, source, options) {
         if (isIncCommand(key)) {
             const path = parseIncCommand(key);
             if (path) {
-                const pathParts = parsePath(path);
-                const topLevelKey = pathParts[0];
-                // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
-                if (!(topLevelKey in target)) {
-                    trackedCreatedPaths.add(topLevelKey);
-                }
-                const lastKey = pathParts[pathParts.length - 1];
-                const parent = ensureNestedPath(target, pathParts);
-                // If property already exists, store original value for reversal
-                if (lastKey in parent) {
-                    const fullPath = `?.${pathParts.join('?.')}`;
-                    if (!(fullPath in reversal)) {
-                        reversal[fullPath] = parent[lastKey];
+                if (isNestedPath(path)) {
+                    const pathParts = parsePath(path);
+                    const topLevelKey = pathParts[0];
+                    // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
+                    if (!(topLevelKey in target)) {
+                        trackedCreatedPaths.add(topLevelKey);
+                    }
+                    const lastKey = pathParts[pathParts.length - 1];
+                    const parent = ensureNestedPath(target, pathParts);
+                    // If property already exists, store original value for reversal
+                    if (lastKey in parent) {
+                        const fullPath = `?.${pathParts.join('?.')}`;
+                        if (!(fullPath in reversal)) {
+                            reversal[fullPath] = parent[lastKey];
+                        }
+                        parent[lastKey] += value;
+                    }
+                    else {
+                        // Property doesn't exist, create it with the value
+                        parent[lastKey] = value;
                     }
-                    parent[lastKey] += value;
                 }
                 else {
-                    // Property doesn't exist, create it with the value
-                    parent[lastKey] = value;
+                    // Plain key - direct operation on target
+                    if (path in target) {
+                        if (!(path in reversal)) {
+                            reversal[path] = target[path];
+                        }
+                        target[path] += value;
+                    }
+                    else {
+                        target[path] = value;
+                    }
                 }
             }
             continue;
@@ -135,27 +151,37 @@ export function assignTentatively(target, source, options) {
             const lhsPath = parseToggleCommand(key);
             if (lhsPath) {
                 const rhsPath = value;
-                const pathParts = parsePath(lhsPath);
-                const topLevelKey = pathParts[0];
-                // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
-                if (!(topLevelKey in target)) {
-                    trackedCreatedPaths.add(topLevelKey);
+                let lhsParent;
+                let lhsLastKey;
+                let lhsPathParts;
+                if (isNestedPath(lhsPath)) {
+                    lhsPathParts = parsePath(lhsPath);
+                    const topLevelKey = lhsPathParts[0];
+                    // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
+                    if (!(topLevelKey in target)) {
+                        trackedCreatedPaths.add(topLevelKey);
+                    }
+                    lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
+                    lhsParent = ensureNestedPath(target, lhsPathParts);
+                }
+                else {
+                    lhsPathParts = [lhsPath];
+                    lhsLastKey = lhsPath;
+                    lhsParent = target;
                 }
-                const lastKey = pathParts[pathParts.length - 1];
-                const parent = ensureNestedPath(target, pathParts);
                 // Determine what to negate
                 let valueToNegate;
                 if (rhsPath === '.') {
                     // Self-reference
-                    if (lastKey in parent) {
-                        valueToNegate = parent[lastKey];
+                    if (lhsLastKey in lhsParent) {
+                        valueToNegate = lhsParent[lhsLastKey];
                     }
                     else {
                         valueToNegate = undefined;
                     }
                 }
-                else {
-                    // RHS path: navigate to get the value (don't create paths)
+                else if (isNestedPath(rhsPath)) {
+                    // RHS nested path: navigate to get the value (don't create paths)
                     const rhsPathParts = parsePath(rhsPath);
                     let current = target;
                     let exists = true;
@@ -170,14 +196,18 @@ export function assignTentatively(target, source, options) {
                     }
                     valueToNegate = exists ? current : true;
                 }
+                else {
+                    // Plain key RHS
+                    valueToNegate = (rhsPath in target) ? target[rhsPath] : true;
+                }
                 // Store original value for reversal if it exists
-                if (lastKey in parent) {
-                    const fullPath = `?.${pathParts.join('?.')}`;
+                if (lhsLastKey in lhsParent) {
+                    const fullPath = `?.${lhsPathParts.join('?.')}`;
                     if (!(fullPath in reversal)) {
-                        reversal[fullPath] = parent[lastKey];
+                        reversal[fullPath] = lhsParent[lhsLastKey];
                     }
                 }
-                parent[lastKey] = !valueToNegate;
+                lhsParent[lhsLastKey] = !valueToNegate;
             }
             continue;
         }
@@ -185,26 +215,38 @@ export function assignTentatively(target, source, options) {
         if (isDeleteCommand(key)) {
             const path = parseDeleteCommand(key);
             if (path !== null) {
-                const pathParts = parsePath(path);
                 // Determine the parent object
                 let parent = target;
                 let canDelete = true;
-                // If path is empty or just '?', delete from root
-                if (pathParts.length === 0) {
-                    parent = target;
-                }
-                else {
-                    // Navigate to parent without creating intermediate paths
-                    for (const part of pathParts) {
-                        if (parent && typeof parent === 'object' && part in parent) {
-                            parent = parent[part];
-                        }
-                        else {
-                            canDelete = false;
-                            break;
+                let pathParts = [];
+                if (isNestedPath(path)) {
+                    pathParts = parsePath(path);
+                    if (pathParts.length === 0) {
+                        parent = target;
+                    }
+                    else {
+                        for (const part of pathParts) {
+                            if (parent && typeof parent === 'object' && part in parent) {
+                                parent = parent[part];
+                            }
+                            else {
+                                canDelete = false;
+                                break;
+                            }
                         }
                     }
                 }
+                else if (path.length > 0) {
+                    // Plain key - navigate one level
+                    pathParts = [path];
+                    if (parent && typeof parent === 'object' && path in parent) {
+                        parent = parent[path];
+                    }
+                    else {
+                        canDelete = false;
+                    }
+                }
+                // else: empty path = delete from root
                 if (canDelete && typeof parent === 'object' && parent !== null) {
                     // RHS can be a string (single property) or array (multiple properties)
                     const propertiesToDelete = Array.isArray(value) ? value : [value];
@@ -212,7 +254,7 @@ export function assignTentatively(target, source, options) {
                         if (prop in parent) {
                             // Store original value for reversal
                             const fullPath = pathParts.length > 0
-                                ? `?.${pathParts.join('?.')}.${prop}`
+                                ? `?.${pathParts.join('?.')}?.${prop}`
                                 : `?.${prop}`;
                             if (!(fullPath in reversal)) {
                                 reversal[fullPath] = parent[prop];

package/assignTentatively.ts

@@ -58,11 +58,13 @@ function parseDeleteCommand(key: string): string | null {
 
 /**
  * Helper function to parse a path string with ?. notation
+ * Always splits on '?.' delimiter, preserving dots that are part of values
+ * (e.g., CSS class selectors like '.username')
+ * Paths must use ?. notation — plain dot notation is not supported.
  */
 function parsePath(path: string): string[] {
   return path
-    .split('.')
-    .map(part => part.replace(/\?/g, ''))
+    .split('?.')
     .filter(part => part.length > 0);
 }
 
@@ -132,27 +134,39 @@ export function assignTentatively(
     if (isIncCommand(key)) {
       const path = parseIncCommand(key);
       if (path) {
-        const pathParts = parsePath(path);
-        const topLevelKey = pathParts[0];
-        
-        // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
-        if (!(topLevelKey in target)) {
-          trackedCreatedPaths.add(topLevelKey);
-        }
-        
-        const lastKey = pathParts[pathParts.length - 1];
-        const parent = ensureNestedPath(target, pathParts);
+        if (isNestedPath(path)) {
+          const pathParts = parsePath(path);
+          const topLevelKey = pathParts[0];
+          
+          // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
+          if (!(topLevelKey in target)) {
+            trackedCreatedPaths.add(topLevelKey);
+          }
+          
+          const lastKey = pathParts[pathParts.length - 1];
+          const parent = ensureNestedPath(target, pathParts);
 
-        // If property already exists, store original value for reversal
-        if (lastKey in parent) {
-          const fullPath = `?.${pathParts.join('?.')}`;
-          if (!(fullPath in reversal)) {
-            reversal[fullPath] = parent[lastKey];
+          // If property already exists, store original value for reversal
+          if (lastKey in parent) {
+            const fullPath = `?.${pathParts.join('?.')}`;
+            if (!(fullPath in reversal)) {
+              reversal[fullPath] = parent[lastKey];
+            }
+            parent[lastKey] += value;
+          } else {
+            // Property doesn't exist, create it with the value
+            parent[lastKey] = value;
           }
-          parent[lastKey] += value;
         } else {
-          // Property doesn't exist, create it with the value
-          parent[lastKey] = value;
+          // Plain key - direct operation on target
+          if (path in target) {
+            if (!(path in reversal)) {
+              reversal[path] = target[path];
+            }
+            target[path] += value;
+          } else {
+            target[path] = value;
+          }
         }
       }
       continue;
@@ -163,28 +177,39 @@ export function assignTentatively(
       const lhsPath = parseToggleCommand(key);
       if (lhsPath) {
         const rhsPath = value;
-        const pathParts = parsePath(lhsPath);
-        const topLevelKey = pathParts[0];
         
-        // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
-        if (!(topLevelKey in target)) {
-          trackedCreatedPaths.add(topLevelKey);
-        }
+        let lhsParent: any;
+        let lhsLastKey: string;
+        let lhsPathParts: string[];
         
-        const lastKey = pathParts[pathParts.length - 1];
-        const parent = ensureNestedPath(target, pathParts);
+        if (isNestedPath(lhsPath)) {
+          lhsPathParts = parsePath(lhsPath);
+          const topLevelKey = lhsPathParts[0];
+          
+          // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
+          if (!(topLevelKey in target)) {
+            trackedCreatedPaths.add(topLevelKey);
+          }
+          
+          lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
+          lhsParent = ensureNestedPath(target, lhsPathParts);
+        } else {
+          lhsPathParts = [lhsPath];
+          lhsLastKey = lhsPath;
+          lhsParent = target;
+        }
 
         // Determine what to negate
         let valueToNegate;
         if (rhsPath === '.') {
           // Self-reference
-          if (lastKey in parent) {
-            valueToNegate = parent[lastKey];
+          if (lhsLastKey in lhsParent) {
+            valueToNegate = lhsParent[lhsLastKey];
           } else {
             valueToNegate = undefined;
           }
-        } else {
-          // RHS path: navigate to get the value (don't create paths)
+        } else if (isNestedPath(rhsPath)) {
+          // RHS nested path: navigate to get the value (don't create paths)
           const rhsPathParts = parsePath(rhsPath);
           let current = target;
           let exists = true;
@@ -199,17 +224,20 @@ export function assignTentatively(
           }
           
           valueToNegate = exists ? current : true;
+        } else {
+          // Plain key RHS
+          valueToNegate = (rhsPath in target) ? target[rhsPath] : true;
         }
 
         // Store original value for reversal if it exists
-        if (lastKey in parent) {
-          const fullPath = `?.${pathParts.join('?.')}`;
+        if (lhsLastKey in lhsParent) {
+          const fullPath = `?.${lhsPathParts.join('?.')}`;
           if (!(fullPath in reversal)) {
-            reversal[fullPath] = parent[lastKey];
+            reversal[fullPath] = lhsParent[lhsLastKey];
           }
         }
         
-        parent[lastKey] = !valueToNegate;
+        lhsParent[lhsLastKey] = !valueToNegate;
       }
       continue;
     }
@@ -218,26 +246,35 @@ export function assignTentatively(
     if (isDeleteCommand(key)) {
       const path = parseDeleteCommand(key);
       if (path !== null) {
-        const pathParts = parsePath(path);
-
         // Determine the parent object
         let parent = target;
         let canDelete = true;
+        let pathParts: string[] = [];
 
-        // If path is empty or just '?', delete from root
-        if (pathParts.length === 0) {
-          parent = target;
-        } else {
-          // Navigate to parent without creating intermediate paths
-          for (const part of pathParts) {
-            if (parent && typeof parent === 'object' && part in parent) {
-              parent = parent[part];
-            } else {
-              canDelete = false;
-              break;
+        if (isNestedPath(path)) {
+          pathParts = parsePath(path);
+          if (pathParts.length === 0) {
+            parent = target;
+          } else {
+            for (const part of pathParts) {
+              if (parent && typeof parent === 'object' && part in parent) {
+                parent = parent[part];
+              } else {
+                canDelete = false;
+                break;
+              }
             }
           }
+        } else if (path.length > 0) {
+          // Plain key - navigate one level
+          pathParts = [path];
+          if (parent && typeof parent === 'object' && path in parent) {
+            parent = parent[path];
+          } else {
+            canDelete = false;
+          }
         }
+        // else: empty path = delete from root
 
         if (canDelete && typeof parent === 'object' && parent !== null) {
           // RHS can be a string (single property) or array (multiple properties)
@@ -247,7 +284,7 @@ export function assignTentatively(
             if (prop in parent) {
               // Store original value for reversal
               const fullPath = pathParts.length > 0 
-                ? `?.${pathParts.join('?.')}.${prop}` 
+                ? `?.${pathParts.join('?.')}?.${prop}` 
                 : `?.${prop}`;
               if (!(fullPath in reversal)) {
                 reversal[fullPath] = parent[prop];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {

package/resolveValues.js

@@ -1,3 +1,52 @@
+/**
+ * Apply alias substitutions to a path string.
+ * Replaces complete tokens between `?.` delimiters with their aliased values.
+ */
+function applyAliases(path, aliasMap) {
+    if (aliasMap.size === 0)
+        return path;
+    const parts = path.split('?.');
+    const substituted = parts.map(part => aliasMap.get(part) ?? part);
+    return substituted.join('?.');
+}
+/**
+ * Navigate a path against a source object, optionally calling methods.
+ * Returns the resolved value at the end of the path.
+ */
+function navigatePath(source, parts, withMethods) {
+    let current = source;
+    let i = 0;
+    while (i < parts.length) {
+        if (current == null)
+            return current;
+        const part = parts[i];
+        if (withMethods && withMethods.has(part)) {
+            const method = current[part];
+            if (typeof method === 'function') {
+                const nextPart = parts[i + 1];
+                if (nextPart !== undefined && !(withMethods.has(nextPart))) {
+                    // Call method with next segment as argument, consume it
+                    current = method.call(current, nextPart);
+                    i += 2;
+                }
+                else {
+                    // Consecutive methods or last segment — call with no args
+                    current = method.call(current);
+                    i++;
+                }
+            }
+            else {
+                current = current[part];
+                i++;
+            }
+        }
+        else {
+            current = current[part];
+            i++;
+        }
+    }
+    return current;
+}
 /**
  * Resolve RHS path strings in a pattern object against a source object.
  *
@@ -5,36 +54,55 @@
  * and resolved against the source object using optional chaining semantics.
  * Non-string values and strings not starting with `?.` pass through unchanged.
  *
+ * Supports `withMethods` for calling methods during resolution and `aka` for
+ * alias substitution, consistent with assignGingerly's LHS path handling.
+ *
+ * Special case: `'?.'` (empty path) resolves to the source object itself.
+ *
  * @param pattern - Object whose RHS values may contain `?.` path strings
  * @param source - Object to resolve paths against
+ * @param options - Optional withMethods and aka for method calls and aliases
  * @returns New object with path strings replaced by resolved values
  *
  * @example
- * const pattern = {
+ * const result = resolveValues({
  *   hello: '?.myPropContainer?.stringProp',
  *   foo: '?.myFooString',
  *   literal: 42
- * };
- * const source = {
- *   myPropContainer: { stringProp: 'Venus' },
- *   myFooString: 'bar'
- * };
- * const result = resolveValues(pattern, source);
- * // { hello: 'Venus', foo: 'bar', literal: 42 }
+ * }, source);
+ *
+ * @example
+ * // With methods and aliases
+ * const result = resolveValues({
+ *   text: '?.q?..username?.textContent'
+ * }, source, {
+ *   withMethods: ['querySelector'],
+ *   aka: { 'q': 'querySelector' }
+ * });
  */
-export function resolveValues(pattern, source) {
+export function resolveValues(pattern, source, options) {
+    // Build alias map
+    const aliasMap = new Map();
+    if (options?.aka) {
+        for (const [alias, target] of Object.entries(options.aka)) {
+            aliasMap.set(alias, target);
+        }
+    }
+    // Build methods set
+    const withMethods = options?.withMethods
+        ? options.withMethods instanceof Set
+            ? options.withMethods
+            : new Set(options.withMethods)
+        : undefined;
     const result = {};
     for (const [key, value] of Object.entries(pattern)) {
         if (typeof value === 'string' && value.startsWith('?.')) {
-            // Parse path: split by '.', strip '?', filter empties
-            const parts = value.split('.').map(p => p.replace(/\?/g, '')).filter(p => p.length > 0);
-            let current = source;
-            for (const part of parts) {
-                if (current == null)
-                    break;
-                current = current[part];
-            }
-            result[key] = current;
+            // Apply aliases to the RHS path
+            const aliased = applyAliases(value, aliasMap);
+            // Parse path: split on '?.' delimiter, filter empties
+            const parts = aliased.split('?.').filter(p => p.length > 0);
+            // Navigate with method support
+            result[key] = parts.length === 0 ? source : navigatePath(source, parts, withMethods);
         }
         else {
             result[key] = value;

package/resolveValues.ts

@@ -1,3 +1,74 @@
+/**
+ * Options for resolveValues
+ */
+export interface ResolveValuesOptions {
+  /**
+   * Method names that should be called instead of accessed as properties.
+   * When a path segment matches, it's called as a method with the next segment as argument.
+   */
+  withMethods?: string[] | Set<string>;
+  
+  /**
+   * Alias mappings for path segments.
+   * Substituted before path resolution, matching complete tokens between `?.` delimiters.
+   */
+  aka?: Record<string, string>;
+}
+
+/**
+ * Apply alias substitutions to a path string.
+ * Replaces complete tokens between `?.` delimiters with their aliased values.
+ */
+function applyAliases(path: string, aliasMap: Map<string, string>): string {
+  if (aliasMap.size === 0) return path;
+  const parts = path.split('?.');
+  const substituted = parts.map(part => aliasMap.get(part) ?? part);
+  return substituted.join('?.');
+}
+
+/**
+ * Navigate a path against a source object, optionally calling methods.
+ * Returns the resolved value at the end of the path.
+ */
+function navigatePath(
+  source: any,
+  parts: string[],
+  withMethods: Set<string> | undefined
+): any {
+  let current = source;
+  let i = 0;
+  
+  while (i < parts.length) {
+    if (current == null) return current;
+    
+    const part = parts[i];
+    
+    if (withMethods && withMethods.has(part)) {
+      const method = current[part];
+      if (typeof method === 'function') {
+        const nextPart = parts[i + 1];
+        if (nextPart !== undefined && !(withMethods.has(nextPart))) {
+          // Call method with next segment as argument, consume it
+          current = method.call(current, nextPart);
+          i += 2;
+        } else {
+          // Consecutive methods or last segment — call with no args
+          current = method.call(current);
+          i++;
+        }
+      } else {
+        current = current[part];
+        i++;
+      }
+    } else {
+      current = current[part];
+      i++;
+    }
+  }
+  
+  return current;
+}
+
 /**
  * Resolve RHS path strings in a pattern object against a source object.
  * 
@@ -5,38 +76,63 @@
  * and resolved against the source object using optional chaining semantics.
  * Non-string values and strings not starting with `?.` pass through unchanged.
  * 
+ * Supports `withMethods` for calling methods during resolution and `aka` for
+ * alias substitution, consistent with assignGingerly's LHS path handling.
+ * 
+ * Special case: `'?.'` (empty path) resolves to the source object itself.
+ * 
  * @param pattern - Object whose RHS values may contain `?.` path strings
  * @param source - Object to resolve paths against
+ * @param options - Optional withMethods and aka for method calls and aliases
  * @returns New object with path strings replaced by resolved values
  * 
  * @example
- * const pattern = {
+ * const result = resolveValues({
  *   hello: '?.myPropContainer?.stringProp',
  *   foo: '?.myFooString',
  *   literal: 42
- * };
- * const source = {
- *   myPropContainer: { stringProp: 'Venus' },
- *   myFooString: 'bar'
- * };
- * const result = resolveValues(pattern, source);
- * // { hello: 'Venus', foo: 'bar', literal: 42 }
+ * }, source);
+ * 
+ * @example
+ * // With methods and aliases
+ * const result = resolveValues({
+ *   text: '?.q?..username?.textContent'
+ * }, source, { 
+ *   withMethods: ['querySelector'],
+ *   aka: { 'q': 'querySelector' }
+ * });
  */
 export function resolveValues(
   pattern: Record<string, any>,
-  source: any
+  source: any,
+  options?: ResolveValuesOptions
 ): Record<string, any> {
+  // Build alias map
+  const aliasMap = new Map<string, string>();
+  if (options?.aka) {
+    for (const [alias, target] of Object.entries(options.aka)) {
+      aliasMap.set(alias, target);
+    }
+  }
+  
+  // Build methods set
+  const withMethods = options?.withMethods
+    ? options.withMethods instanceof Set
+      ? options.withMethods
+      : new Set(options.withMethods)
+    : undefined;
+  
   const result: Record<string, any> = {};
   for (const [key, value] of Object.entries(pattern)) {
     if (typeof value === 'string' && value.startsWith('?.')) {
-      // Parse path: split by '.', strip '?', filter empties
-      const parts = value.split('.').map(p => p.replace(/\?/g, '')).filter(p => p.length > 0);
-      let current = source;
-      for (const part of parts) {
-        if (current == null) break;
-        current = current[part];
-      }
-      result[key] = current;
+      // Apply aliases to the RHS path
+      const aliased = applyAliases(value, aliasMap);
+      
+      // Parse path: split on '?.' delimiter, filter empties
+      const parts = aliased.split('?.').filter(p => p.length > 0);
+      
+      // Navigate with method support
+      result[key] = parts.length === 0 ? source : navigatePath(source, parts, withMethods);
     } else {
       result[key] = value;
     }