assign-gingerly 0.0.54 → 0.0.56

package/README.md

@@ -9,7 +9,7 @@
 
 ## Introduction
 
-This package starts out innocently enough -- it provides three utility functions for carefully merging one object into another.  This is a primitive sorely lacking in the web, and this package is a polyfill for what we (me with a lot of help from AI) would like to see built into the platform.  We make no apologies about adding these features directly to the underlying API's, as it is part of a proposal which is sitting there gathering dust, with no apparent alternatives under consideration.  In particular the reference:
+This package starts out innocently enough -- it provides the ability to carefully merge one object into another.  This is a primitive sorely lacking in the web, and this package is a polyfill for what we (me with a lot of help from AI) would like to see built into the platform.  We make no apologies about adding these features directly to the underlying API's, as it is part of a proposal which is sitting there gathering dust, with no apparent alternatives under consideration.  In particular the reference:
 
 ```JavaScript
 import 'assign-gingerly/object-extension.js';
@@ -1131,7 +1131,7 @@ const result = assignGingerly({}, {
     "[Symbol.for('BqnnTPWRHkWdVGWcGQoAiw')]": true,
     style: {
       height: '40px'
-    }
+    },
     enh: {
       mellowYellow?.madAboutFourteen': true
     }
@@ -4126,6 +4126,104 @@ The `#[x]` + `withIds` pattern gives you the Map+WeakRef speed tier automaticall
 - **Scoped to rootNode** — works correctly inside Shadow DOM (IDs are scoped per shadow root).
 - **`assignFrom` only** — this feature is not available in `assignGingerly` or `assignTentatively`.
 
+## Inferred Assignments
+
+`assignFrom` can automatically distribute source values to matching DOM elements based on structural conventions — no manual path strings needed. The [inferencer](./inferencer/) submodule determines the correct property for each element type.
+
+```TypeScript
+const vm = {
+    name: 'Alice',
+    email: 'alice@example.com',
+    user: { role: 'admin', avatar: '/img/alice.png' }
+};
+
+await assignFrom(outerDiv, {}, {
+    from: vm,
+    inferredAssignments: {
+        byItemprop: ['name', 'email', 'user']
+    }
+});
+```
+
+For each key in `byItemprop`, this finds `[itemprop="${key}"]` elements within the target (respecting itemscope boundaries) and sets the value using the inferred property:
+
+| Element | Inferred Property |
+|---------|------------------|
+| `<span itemprop="name">` | `textContent` |
+| `<input itemprop="email">` | `value` |
+| `<time itemprop="date">` | `dateTime` |
+| `<data itemprop="count">` | `value` |
+| `<div itemprop="user" itemscope="user-card">` | `ish` (manager routing) |
+
+**Scope perimeter:** Queries respect itemscope boundaries — `[itemprop="name"]` inside a nested `[itemscope]` won't be matched from the outer scope (donut-hole scoping).
+
+**Pass `true` to infer all source keys:**
+
+```TypeScript
+inferredAssignments: { byItemprop: true }
+```
+
+For full details, see [docs/inferred-assignments.md](docs/inferred-assignments.md).
+
+## Bulk Enhancement with `enhance` and `enhanceAll`
+
+Apply enhancements in bulk to matching elements using EMC (Element Mount Configuration) JSON files that enhancement packages already publish. No manual registration step needed — enhancements are auto-loaded and registered on demand.
+
+```TypeScript
+import { assignFrom } from 'assign-gingerly/assignFrom.js';
+
+await assignFrom(shadowRoot, { /* normal assignments */ }, {
+    from: vm,
+    enhance: [
+        { emc: 'be-bound/emc.json', matching: '[name]' },
+        { emc: 'be-observant/emc.json', matching: '[itemprop]' },
+    ]
+});
+```
+
+**How it works:**
+
+1. Dynamically imports each EMC JSON file
+2. Extracts the `enhConfig` (spawn path, enhKey)
+3. Finds matching elements via `querySelectorAll` (using `matching` override, or the EMC's own selector)
+4. Registers the enhancement in the element's `enhancementRegistry` if not already present
+5. Spawns the enhancement on each matched element via `element.enh.get(registryItem)`
+
+**Standalone usage (without `assignFrom`):**
+
+```TypeScript
+import { enhanceAll } from 'assign-gingerly/enhanceAll.js';
+
+await enhanceAll(shadowRoot, [
+    { emc: 'be-bound/emc.json', matching: '[name]' },
+]);
+```
+
+**With `assignGingerly` (fire-and-forget):**
+
+```TypeScript
+assignGingerly(shadowRoot, {
+    '?.someProperty': 'value'
+}, {
+    enhance: [{ emc: 'be-bound/emc.json', matching: '[name]' }]
+});
+// Enhancements apply asynchronously in the background
+```
+
+**Configuration:**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `emc` | `string` | Path to EMC JSON file (dynamically imported) |
+| `matching` | `string?` | CSS selector override (defaults to EMC's own selector) |
+| `parse` | `boolean?` | Parse attributes via withAttrs (default: `false`, Phase II) |
+
+**Notes:**
+
+- No scope perimeter is applied — the selector does all filtering. For reactive observation of new elements, use [mount-observer](https://github.com/bahrus/mount-observer) instead.
+- Requires JSON module import support (`import ... with { type: 'json' }`).
+- Enhancement modules are loaded lazily — zero cost until `enhance` is used.
+
 ## Custom Assignment with `static assignTo` Protocol
 
 Classes can opt into custom assignment behavior by defining a `static assignTo` method. When `assignGingerly` encounters a property whose current value is an instance of such a class, it delegates the assignment to `assignTo` instead of performing the default merge/replace logic.
@@ -4788,6 +4886,33 @@ This is useful for:
 4. On first access, the getter spawns the feature instance, validates it (optionally), caches it, and returns it.
 5. Because the property is getter-only (no setter), `assignGingerly` automatically merges into the spawned instance when assigning object values to that property.
 
+### Features at Registration Time
+
+Features can also be bundled directly into enhancement and itemscope manager registration configs — no separate `assignFeatures` call needed:
+
+```TypeScript
+// Enhancement with features
+enhancementRegistry.push({
+    spawn: MyEnhancement,
+    enhKey: 'myEnh',
+    features: {
+        photoTaker: { spawn: PhotoTakerImpl },
+        badgeMaker: { spawn: BadgeMakerImpl },
+    }
+});
+
+// Itemscope manager with features
+customElements.itemscopeRegistry.define('my-manager', {
+    manager: MyManagerClass,
+    lifecycleKeys: { dispose: 'cleanup', resolved: 'isReady' },
+    features: {
+        roundabout: { customData: { /* ... */ } },
+    }
+});
+```
+
+This calls `assignFeatures` automatically under the hood using the shared `customElements.featuresRegistry`. The standalone `assignFeatures` call remains available for cases where you need to associate features with a class you don't own or after initial registration.
+
 ### Basic example
 
 ```JavaScript
@@ -5660,3 +5785,19 @@ See [time-ticker/wireFeatures.js](https://github.com/bahrus/time-ticker/blob/bas
 
 - **Nested features**: Support `?.path?.notation` keys directly in `assignFeatures` (without requiring `PropertyBag`).
 - **`@each` + async interaction**: Combine async methods with iteration.
+
+
+## Viewing Locally
+
+Any web server that serves static files with server-side includes will do but...
+
+1. Install git
+2. Fork/clone this repo
+3. Install node.js
+4. Open command window to folder where you cloned this repo
+5. > git submodule add https://github.com/bahrus/types.git types
+6. > git submodule add https://github.com/bahrus/inferencer.git inferencer
+7. > git submodule update --init --recursive
+8. > npm install
+9. > npm run serve
+10. Open http://localhost:8000/demo/ in a modern browser

package/assignFrom.js

@@ -140,7 +140,7 @@ function mergeHandlerDuplicates(entries) {
     }
     return result;
 }
-export async function assignFrom(target, pattern, options) {
+export async function assignFrom(target, pattern, options, permissions) {
     // First: expand looped substitution variables (${x}, ${y}, ${z})
     const expandedPattern = expandSubstitutions(pattern, options);
     // Separate handler commands ( =>), #[x] keys, and normal keys
@@ -180,27 +180,25 @@ export async function assignFrom(target, pattern, options) {
         const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
         for (const key of idRefNormalKeys) {
             const parsed = parseIdRef(key);
-            if (!parsed) continue;
+            if (!parsed)
+                continue;
             const el = resolveIdVariable(parsed.varName, target, options.withIds);
-            if (!el) continue;
+            if (!el)
+                continue;
             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, protocols: options.protocols }
-                );
+                const resolvedValue = await resolveValues({ __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols });
                 // 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, protocols: options.protocols }
-                );
-                if (!('__v' in resolvedValue)) {
+                const resolvedValue = await resolveValues(typeof value === 'object' && value !== null ? value : { __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols });
+                if ('__v' in resolvedValue) {
+                    // Single value — can't assign to element root without a path
+                }
+                else {
                     assignGingerly(el, resolvedValue, options);
                 }
             }
@@ -209,7 +207,7 @@ export async function assignFrom(target, pattern, options) {
     // Process handler commands ( =>) — dynamically imported only when needed
     if (handlerKeys.length > 0) {
         const { processHandlerCommands } = await import('./processHandlerCommands.js');
-        await processHandlerCommands(target, handlerKeys, expandedPattern, options);
+        await processHandlerCommands(target, handlerKeys, expandedPattern, options, permissions);
     }
     // Process #[x] handler keys — resolve element, then pass to handler processing
     if (idRefHandlerKeys.length > 0 && options.withIds) {
@@ -217,19 +215,40 @@ export async function assignFrom(target, pattern, options) {
         const { processHandlerCommands } = await import('./processHandlerCommands.js');
         for (const key of idRefHandlerKeys) {
             const parsed = parseIdRef(key);
-            if (!parsed) continue;
+            if (!parsed)
+                continue;
             const el = resolveIdVariable(parsed.varName, target, options.withIds);
-            if (!el) continue;
-            // Build a synthetic key for processHandlerCommands
+            if (!el)
+                continue;
+            // Build a synthetic key for processHandlerCommands:
+            // The resolved element becomes the target, remaining path is the LHS
             const syntheticKey = parsed.remainingPath
                 ? `${parsed.remainingPath} =>`
                 : ' =>';
             const syntheticPattern = {
                 [syntheticKey]: expandedPattern[key]
             };
-            await processHandlerCommands(el, [syntheticKey], syntheticPattern, options);
+            await processHandlerCommands(el, [syntheticKey], syntheticPattern, options, permissions);
         }
     }
+    // Process inferred assignments — dynamically imported only when option is present
+    if (options.inferredAssignments) {
+        const { processInferredAssignments } = await import('./inferredAssignments.js');
+        await processInferredAssignments(target, options.from, options.inferredAssignments);
+        // Set up MutationObserver for new matching elements if beVigilant
+        if (options.inferredAssignments.beVigilant) {
+            if (!options.signal) {
+                throw new Error('assignFrom: inferredAssignments.beVigilant requires options.signal (AbortSignal) for cleanup');
+            }
+            const { setupVigilantObserver } = await import('./beVigilant.js');
+            setupVigilantObserver(target, options.from, options.inferredAssignments, options.signal);
+        }
+    }
+    // Process bulk enhancements — dynamically imported only when option is present
+    if (options.enhance && options.enhance.length > 0) {
+        const { enhanceAll } = await import('./enhanceAll.js');
+        await enhanceAll(target, options.enhance, permissions);
+    }
     return target;
 }
 /**

package/assignFrom.ts

@@ -21,6 +21,7 @@
  */
 import { resolveValues, ResolveValuesOptions } from './resolveValues.js';
 import assignGingerly, { IAssignGingerlyOptions } from './assignGingerly.js';
+import type { AssignPermissions } from './isAllowedImportPath.js';
 
 export interface AssignFromOptions extends IAssignGingerlyOptions, ResolveValuesOptions {
   /** Source object to resolve RHS path strings against */
@@ -63,6 +64,42 @@ export interface AssignFromOptions extends IAssignGingerlyOptions, ResolveValues
    * }
    */
   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
+   * inferredAssignments: {
+   *     byItemprop: ['user', 'name', 'email'],  // or true for all source keys
+   *     beVigilant: true,  // watch for new matching elements (requires signal)
+   * }
+   */
+  inferredAssignments?: {
+    byItemprop?: string[] | true;
+    /** 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 }>;
 }
 
 /**
@@ -205,7 +242,8 @@ function mergeHandlerDuplicates(entries: [string, any][]): Record<string, any> {
 export async function assignFrom(
   target: any,
   pattern: Record<string, any>,
-  options: AssignFromOptions
+  options: AssignFromOptions,
+  permissions?: AssignPermissions
 ): Promise<any> {
   // First: expand looped substitution variables (${x}, ${y}, ${z})
   const expandedPattern = expandSubstitutions(pattern, options);
@@ -282,7 +320,7 @@ export async function assignFrom(
   // Process handler commands ( =>) — dynamically imported only when needed
   if (handlerKeys.length > 0) {
     const { processHandlerCommands } = await import('./processHandlerCommands.js');
-    await processHandlerCommands(target, handlerKeys, expandedPattern, options);
+    await processHandlerCommands(target, handlerKeys, expandedPattern, options, permissions);
   }
 
   // Process #[x] handler keys — resolve element, then pass to handler processing
@@ -307,10 +345,31 @@ export async function assignFrom(
         [syntheticKey]: expandedPattern[key]
       };
 
-      await processHandlerCommands(el, [syntheticKey], syntheticPattern, options);
+      await processHandlerCommands(el, [syntheticKey], syntheticPattern, options, permissions);
     }
   }
 
+  // Process inferred assignments — dynamically imported only when option is present
+  if (options.inferredAssignments) {
+    const { processInferredAssignments } = await import('./inferredAssignments.js');
+    await processInferredAssignments(target, options.from, options.inferredAssignments);
+
+    // Set up MutationObserver for new matching elements if beVigilant
+    if (options.inferredAssignments.beVigilant) {
+      if (!options.signal) {
+        throw new Error('assignFrom: inferredAssignments.beVigilant requires options.signal (AbortSignal) for cleanup');
+      }
+      const { setupVigilantObserver } = await import('./beVigilant.js');
+      setupVigilantObserver(target, options.from, options.inferredAssignments, options.signal);
+    }
+  }
+
+  // Process bulk enhancements — dynamically imported only when option is present
+  if (options.enhance && options.enhance.length > 0) {
+    const { enhanceAll } = await import('./enhanceAll.js');
+    await enhanceAll(target, options.enhance, permissions);
+  }
+
   return target;
 }
 

package/assignGingerly.js

@@ -42,6 +42,21 @@ export class EnhancementRegistry extends EventTarget {
         }
         // Dispatch event after adding items
         this.dispatchEvent(new EnhancementRegisteredEvent(items));
+        // Process features if present (fire-and-forget, uses shared featuresRegistry)
+        const itemsArr = Array.isArray(items) ? items : [items];
+        for (const item of itemsArr) {
+            if (item.features) {
+                this.#assignFeatures(item.spawn, item.features);
+            }
+        }
+    }
+    async #assignFeatures(spawn, features) {
+        const { assignFeatures } = await import('./assignFeatures.js');
+        const featuresRegistry = this._featuresRegistry
+            ?? (typeof customElements !== 'undefined' ? customElements.featuresRegistry : undefined);
+        if (featuresRegistry) {
+            assignFeatures(spawn, features, featuresRegistry);
+        }
     }
     getItems() {
         return Array.from(this.#items);
@@ -89,6 +104,18 @@ export class ItemscopeRegistry extends EventTarget {
         }
         this.#configs.set(name, config);
         this.dispatchEvent(new Event(name));
+        // Process features if present (fire-and-forget, uses shared featuresRegistry)
+        if (config.features) {
+            this.#assignFeatures(config.manager, config.features);
+        }
+    }
+    async #assignFeatures(manager, features) {
+        const { assignFeatures } = await import('./assignFeatures.js');
+        const featuresRegistry = this._featuresRegistry
+            ?? (typeof customElements !== 'undefined' ? customElements.featuresRegistry : undefined);
+        if (featuresRegistry) {
+            assignFeatures(manager, features, featuresRegistry);
+        }
     }
     /**
      * Get a manager configuration by name
@@ -515,7 +542,7 @@ function applyAliases(key, aliasMap) {
 /**
  * Main assignGingerly function
  */
-export function assignGingerly(target, source, options) {
+export function assignGingerly(target, source, options, permissions) {
     if (!target || typeof target !== 'object') {
         return target;
     }
@@ -1059,6 +1086,12 @@ export function assignGingerly(target, source, options) {
             configurable: true,
         });
     }
+    // Fire-and-forget bulk enhancements (async, non-blocking)
+    if (options?.enhance && options.enhance.length > 0 && typeof target === 'object' && target instanceof Element) {
+        import('./enhanceAll.js').then(({ enhanceAll }) => {
+            enhanceAll(target, options.enhance, permissions);
+        });
+    }
     return target;
 }
 export default assignGingerly;

package/assignGingerly.ts

@@ -1,6 +1,8 @@
 
 
 import { EnhancementConfig } from "./types/assign-gingerly/types";
+import type { FeatureConfigsMap } from "./types/assign-gingerly/types";
+import type { AssignPermissions } from "./isAllowedImportPath.js";
 
 /**
  * Constructor signature for ItemScope Manager classes
@@ -116,6 +118,18 @@ export interface IAssignGingerlyOptions {
    * // Calls: (await el.whenFeatureReady('photoTaker')).someProp = 'hello'
    */
   withAsyncMethods?: string[] | Set<string>;
+
+  /**
+   * Bulk enhancement application via EMC JSON configs.
+   * Finds matching elements and spawns enhancements on them.
+   * Fire-and-forget (async) — assignGingerly remains synchronous.
+   * 
+   * @example
+   * enhance: [
+   *     { emc: 'be-bound/emc.json', matching: '[name]' },
+   * ]
+   */
+  enhance?: Array<{ emc: string; matching?: string; parse?: boolean }>;
 }
 
 /**
@@ -167,6 +181,23 @@ export class EnhancementRegistry extends EventTarget {
     
     // Dispatch event after adding items
     this.dispatchEvent(new EnhancementRegisteredEvent(items));
+
+    // Process features if present (fire-and-forget, uses shared featuresRegistry)
+    const itemsArr = Array.isArray(items) ? items : [items];
+    for (const item of itemsArr) {
+      if (item.features) {
+        this.#assignFeatures(item.spawn, item.features);
+      }
+    }
+  }
+
+  async #assignFeatures(spawn: any, features: FeatureConfigsMap): Promise<void> {
+    const { assignFeatures } = await import('./assignFeatures.js');
+    const featuresRegistry = (this as any)._featuresRegistry
+      ?? (typeof customElements !== 'undefined' ? (customElements as any).featuresRegistry : undefined);
+    if (featuresRegistry) {
+      assignFeatures(spawn, features, featuresRegistry);
+    }
   }
 
   getItems(): EnhancementConfig[] {
@@ -218,6 +249,20 @@ export class ItemscopeRegistry extends EventTarget {
     }
     this.#configs.set(name, config);
     this.dispatchEvent(new Event(name));
+
+    // Process features if present (fire-and-forget, uses shared featuresRegistry)
+    if ((config as any).features) {
+      this.#assignFeatures(config.manager, (config as any).features);
+    }
+  }
+
+  async #assignFeatures(manager: any, features: FeatureConfigsMap): Promise<void> {
+    const { assignFeatures } = await import('./assignFeatures.js');
+    const featuresRegistry = (this as any)._featuresRegistry
+      ?? (typeof customElements !== 'undefined' ? (customElements as any).featuresRegistry : undefined);
+    if (featuresRegistry) {
+      assignFeatures(manager, features, featuresRegistry);
+    }
   }
 
   /**
@@ -691,7 +736,8 @@ function applyAliases(key: string, aliasMap: Map<string, string>): string {
 export function assignGingerly(
   target: any,
   source: Record<string | symbol, any>,
-  options?: IAssignGingerlyOptions
+  options?: IAssignGingerlyOptions,
+  permissions?: AssignPermissions
 ): any {
   if (!target || typeof target !== 'object') {
     return target;
@@ -1274,6 +1320,13 @@ export function assignGingerly(
     });
   }
 
+  // Fire-and-forget bulk enhancements (async, non-blocking)
+  if (options?.enhance && options.enhance.length > 0 && typeof target === 'object' && target instanceof Element) {
+    import('./enhanceAll.js').then(({ enhanceAll }) => {
+      enhanceAll(target, options!.enhance!, permissions);
+    });
+  }
+
   return target;
 }
 

package/beVigilant.js

@@ -0,0 +1,73 @@
+/**
+ * beVigilant.ts — MutationObserver-based reactive inference for newly added elements.
+ *
+ * Dynamically imported when `inferredAssignments.beVigilant: true` is set.
+ * Watches for new [itemprop] elements and attribute changes, applying inferred
+ * assignments from the live `from` object.
+ *
+ * Requires an AbortSignal for cleanup (disconnects the observer on abort).
+ */
+import { Infer } from './inferencer/inferencer.js';
+import { withScopePerimeter } from './inferencer/withScopePerimeter.js';
+import { registerInCache } from './resolveIdRef.js';
+/**
+ * Set up a MutationObserver that watches for new [itemprop] elements
+ * and applies inferred assignments from the live `from` object.
+ *
+ * @param target - The DOM element to observe
+ * @param from - The live source object (read at observation time for current values)
+ * @param config - The inferredAssignments config (byItemprop keys)
+ * @param signal - AbortSignal for cleanup (required)
+ */
+export function setupVigilantObserver(target, from, config, signal) {
+    const keys = config.byItemprop === true ? null : new Set(config.byItemprop);
+    const observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+            if (mutation.type === 'childList') {
+                // Process added nodes and their descendants
+                for (const node of mutation.addedNodes) {
+                    if (!(node instanceof Element))
+                        continue;
+                    // Check the added element itself
+                    processElement(node, from, keys, target);
+                    // Check descendants (respecting scope perimeter)
+                    const nested = node.querySelectorAll('[itemprop]');
+                    for (const el of nested) {
+                        processElement(el, from, keys, target);
+                    }
+                }
+            }
+            else if (mutation.type === 'attributes' && mutation.target instanceof Element) {
+                // itemprop attribute was added or changed on an existing element
+                processElement(mutation.target, from, keys, target);
+            }
+        }
+    });
+    observer.observe(target, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ['itemprop']
+    });
+    // Cleanup on abort
+    signal.addEventListener('abort', () => observer.disconnect(), { once: true });
+}
+/**
+ * Process a single element: check if it matches, apply inferred value, cache it.
+ */
+function processElement(element, from, keys, scopeRoot) {
+    const itemprop = element.getAttribute('itemprop');
+    if (!itemprop)
+        return;
+    if (keys && !keys.has(itemprop))
+        return;
+    if (!(itemprop in from))
+        return;
+    if (!withScopePerimeter(scopeRoot, element, '[itemscope]'))
+        return;
+    // Set value via inferencer
+    const infer = new Infer(element, itemprop);
+    infer.value = from[itemprop];
+    // Cache for future fast access
+    registerInCache(scopeRoot, itemprop, element);
+}