assign-gingerly 0.0.84 → 0.0.86

package/ScopedParserRegistry.js

@@ -9,7 +9,7 @@ export class ScopedParserRegistry {
      * Register a parser with a given name
      * Resolves any pending waiters for this parser
      * @param name - The name to register the parser under
-     * @param parser - The parser function
+     * @param parser - The parser function or class constructor
      */
     register(name, parser) {
         if (this.parsers.has(name)) {
@@ -26,7 +26,7 @@ export class ScopedParserRegistry {
     /**
      * Get a parser by name
      * @param name - The name of the parser
-     * @returns The parser function or undefined if not found
+     * @returns The parser function, class constructor, or undefined if not found
      */
     get(name) {
         return this.parsers.get(name);

package/ScopedParserRegistry.ts

@@ -1,11 +1,11 @@
-import { ParserFunction } from './types/assign-gingerly/types';
+import { ParserFunction, AttrParserConstructor } from './types/assign-gingerly/types';
 
 /**
  * Registry for parsers scoped to a synthesizer element (be-hive, htmx-container, etc.)
  * Enables lazy-loading of complex parsers with Promise-based waiting
  */
 export class ScopedParserRegistry {
-  private parsers = new Map<string, ParserFunction>();
+  private parsers = new Map<string, ParserFunction | AttrParserConstructor>();
   private pendingWaits = new Map<string, Array<{
     resolve: () => void;
     reject: (error: Error) => void;
@@ -15,9 +15,9 @@ export class ScopedParserRegistry {
    * Register a parser with a given name
    * Resolves any pending waiters for this parser
    * @param name - The name to register the parser under
-   * @param parser - The parser function
+   * @param parser - The parser function or class constructor
    */
-  register(name: string, parser: ParserFunction): void {
+  register(name: string, parser: ParserFunction | AttrParserConstructor): void {
     if (this.parsers.has(name)) {
       console.warn(`Parser "${name}" already registered in scoped registry, overwriting`);
     }
@@ -35,9 +35,9 @@ export class ScopedParserRegistry {
   /**
    * Get a parser by name
    * @param name - The name of the parser
-   * @returns The parser function or undefined if not found
+   * @returns The parser function, class constructor, or undefined if not found
    */
-  get(name: string): ParserFunction | undefined {
+  get(name: string): ParserFunction | AttrParserConstructor | undefined {
     return this.parsers.get(name);
   }
   

package/SplitParser.js

@@ -0,0 +1,48 @@
+/**
+ * Escapes regex metacharacters so a string delimiter is treated literally.
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Built-in class parser that splits an attribute value into an array.
+ * Registered under the name 'splitter' in globalParserRegistry.
+ */
+export class SplitParser {
+    delimiter;
+    trim;
+    skipEmpty;
+    dedupe;
+    constructor(options) {
+        const opts = options ?? {};
+        const rawDelimiter = opts.delimiter;
+        if (rawDelimiter === undefined) {
+            this.delimiter = /\s+/;
+        }
+        else if (typeof rawDelimiter === 'string') {
+            this.delimiter = rawDelimiter === '' ? /(?:)/ : new RegExp(escapeRegex(rawDelimiter));
+        }
+        else {
+            this.delimiter = new RegExp(rawDelimiter.pattern, rawDelimiter.flags ?? '');
+        }
+        this.trim = opts.trim ?? true;
+        this.skipEmpty = opts.skipEmpty ?? true;
+        this.dedupe = opts.dedupe ?? false;
+    }
+    parse(v, _context) {
+        if (v === null || v === '') {
+            return [];
+        }
+        let parts = v.split(this.delimiter);
+        if (this.trim) {
+            parts = parts.map((s) => s.trim());
+        }
+        if (this.skipEmpty) {
+            parts = parts.filter((s) => s !== '');
+        }
+        if (this.dedupe) {
+            parts = [...new Set(parts)];
+        }
+        return parts;
+    }
+}

package/SplitParser.ts

@@ -0,0 +1,89 @@
+import { AttrParser, ParserContext } from './types/assign-gingerly/types';
+
+/**
+ * Options for SplitParser
+ */
+export interface SplitParserOptions {
+  /**
+   * Delimiter used to split the attribute value.
+   * - String: treated as a literal separator (regex specials are escaped)
+   * - Object: { pattern: string; flags?: string } builds a RegExp directly
+   * - Default: /\s+/
+   */
+  delimiter?: string | { pattern: string; flags?: string };
+
+  /**
+   * Whether to trim each split part.
+   * Default: true
+   */
+  trim?: boolean;
+
+  /**
+   * Whether to skip empty strings after splitting/trimming.
+   * Default: true
+   */
+  skipEmpty?: boolean;
+
+  /**
+   * Whether to remove duplicate values.
+   * Default: false
+   */
+  dedupe?: boolean;
+}
+
+/**
+ * Escapes regex metacharacters so a string delimiter is treated literally.
+ */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Built-in class parser that splits an attribute value into an array.
+ * Registered under the name 'splitter' in globalParserRegistry.
+ */
+export class SplitParser implements AttrParser {
+  private delimiter: RegExp;
+  private trim: boolean;
+  private skipEmpty: boolean;
+  private dedupe: boolean;
+
+  constructor(options?: SplitParserOptions) {
+    const opts = options ?? {};
+    const rawDelimiter = opts.delimiter;
+
+    if (rawDelimiter === undefined) {
+      this.delimiter = /\s+/;
+    } else if (typeof rawDelimiter === 'string') {
+      this.delimiter = rawDelimiter === '' ? /(?:)/ : new RegExp(escapeRegex(rawDelimiter));
+    } else {
+      this.delimiter = new RegExp(rawDelimiter.pattern, rawDelimiter.flags ?? '');
+    }
+
+    this.trim = opts.trim ?? true;
+    this.skipEmpty = opts.skipEmpty ?? true;
+    this.dedupe = opts.dedupe ?? false;
+  }
+
+  parse(v: string | null, _context?: ParserContext): any {
+    if (v === null || v === '') {
+      return [];
+    }
+
+    let parts = v.split(this.delimiter);
+
+    if (this.trim) {
+      parts = parts.map((s) => s.trim());
+    }
+
+    if (this.skipEmpty) {
+      parts = parts.filter((s) => s !== '');
+    }
+
+    if (this.dedupe) {
+      parts = [...new Set(parts)];
+    }
+
+    return parts;
+  }
+}

package/assignFrom.js

@@ -7,11 +7,14 @@
  * For async protocol handlers or awaitable handler execution, use assignFromAsync.
  *
  * Handler commands (` =>`) are fire-and-forget (kicked off asynchronously, not awaited).
+ * Sync-op commands (` =&`) are always fully synchronous — see SYNC_OPS.
  */
 import { getValues, getValue } from './resolve/getValues.js';
 import assignGingerly from './assignGingerly.js';
 import { resolveIdVariable, parseIdRef } from './resolve/resolveIdRef.js';
 import { processInferredAssignments } from './inferredAssignments.js';
+import { resolveLhsPath } from './utils/resolveLhsPath.js';
+import { SYNC_OPS } from './syncOps/registry.js';
 /**
  * Supported substitution variables and their option keys.
  */
@@ -40,6 +43,48 @@ export function parseTernaryCommand(key) {
         return null;
     return key.substring(0, key.length - 3); // Remove ' ?=' suffix
 }
+/**
+ * Check if a key ends with the sync-op operator ' =&'.
+ */
+export function isSyncOpCommand(key) {
+    return key.endsWith(' =&');
+}
+/**
+ * Parse a =& sync-op command and extract the LHS path.
+ */
+export function parseSyncOpCommand(key) {
+    if (!isSyncOpCommand(key))
+        return null;
+    return key.substring(0, key.length - 3); // Remove ' =&' suffix
+}
+/**
+ * Throws if a resolved sync-op value (or anything nested inside it) is a thenable.
+ *
+ * getValues is synchronous by contract, but `options.protocols` handlers are
+ * typed to allow returning a Promise. A sync op has no await to catch that —
+ * left unchecked it would silently stringify as "[object Promise]" — so this
+ * turns it into a clear error instead.
+ */
+function assertNoThenable(value, opName, key) {
+    if (value == null)
+        return;
+    if (typeof value.then === 'function') {
+        throw new Error(`assignFrom: sync op '${opName}' (key "${key}") received an async value — ` +
+            `a protocol in options.protocols returned a Promise, which ' =&' cannot await. ` +
+            `Use ' =>' with 'resolve:' instead for async values.`);
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            assertNoThenable(item, opName, key);
+    }
+    else if (typeof value === 'object') {
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null) {
+            for (const item of Object.values(value))
+                assertNoThenable(item, opName, key);
+        }
+    }
+}
 /**
  * Resolve a single value — if it's a `?.` path string, resolve against source.
  * If it's a protocol string, resolve via protocol. Otherwise pass through as literal.
@@ -343,6 +388,7 @@ export function categorizeKeys(expandedPattern) {
     const idRefNormalKeys = [];
     const idRefHandlerKeys = [];
     const ternaryKeys = [];
+    const syncOpKeys = [];
     for (const key of Object.keys(expandedPattern)) {
         if (isHandlerCommand(key)) {
             if (key.startsWith('#[')) {
@@ -355,6 +401,9 @@ export function categorizeKeys(expandedPattern) {
         else if (isTernaryCommand(key)) {
             ternaryKeys.push(key);
         }
+        else if (isSyncOpCommand(key)) {
+            syncOpKeys.push(key);
+        }
         else if (key.startsWith('#[')) {
             idRefNormalKeys.push(key);
         }
@@ -362,7 +411,7 @@ export function categorizeKeys(expandedPattern) {
             normalPattern[key] = expandedPattern[key];
         }
     }
-    return { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys };
+    return { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys, syncOpKeys };
 }
 /**
  * Merge pin and at into a single lookup map for resolveIdVariable.
@@ -420,7 +469,7 @@ export function assignFrom(target, pattern, options, permissionProcessor) {
     // Expand looped substitution variables
     const expandedPattern = expandSubstitutions(pattern, options);
     // Categorize keys
-    const { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys } = categorizeKeys(expandedPattern);
+    const { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys, syncOpKeys } = categorizeKeys(expandedPattern);
     const resolveOptions = { ...options, root: target, permissionProcessor };
     // Process ?= ternary keys (sync)
     if (ternaryKeys.length > 0) {
@@ -441,6 +490,33 @@ export function assignFrom(target, pattern, options, permissionProcessor) {
             assignGingerly(target, ternaryResolved, options, permissionProcessor);
         }
     }
+    // Process =& sync-op keys (sync — always, no dynamic import, no await, ever)
+    if (syncOpKeys.length > 0) {
+        for (const key of syncOpKeys) {
+            const lhsPath = parseSyncOpCommand(key);
+            if (lhsPath === null)
+                continue;
+            const config = expandedPattern[key];
+            if (!config || typeof config !== 'object' || Array.isArray(config)) {
+                throw new Error(`assignFrom: sync-op command "${key}" requires a config object naming exactly one op`);
+            }
+            const opName = Object.keys(config).find(k => k in SYNC_OPS);
+            if (!opName) {
+                throw new Error(`assignFrom: sync-op command "${key}" does not name a known op (${Object.keys(SYNC_OPS).join(', ')})`);
+            }
+            const resolvedConfig = getValues(config, options.from, resolveOptions);
+            assertNoThenable(resolvedConfig, opName, key);
+            const { [opName]: args, ...extra } = resolvedConfig;
+            const result = SYNC_OPS[opName](args, extra);
+            if (result === undefined)
+                continue;
+            const { lhsParent, lhsKey } = resolveLhsPath(target, lhsPath, options);
+            if (lhsParent != null && lhsKey != null
+                && !permissionProcessor?.redirectRestrictedProp(lhsParent, lhsKey, result)) {
+                lhsParent[lhsKey] = result;
+            }
+        }
+    }
     // Process normal keys via getValues (sync) + assignGingerly
     if (Object.keys(normalPattern).length > 0) {
         // Resolve #[x] references on RHS values before getValues

package/assignFrom.ts

@@ -7,12 +7,15 @@
  * For async protocol handlers or awaitable handler execution, use assignFromAsync.
  * 
  * Handler commands (` =>`) are fire-and-forget (kicked off asynchronously, not awaited).
+ * Sync-op commands (` =&`) are always fully synchronous — see SYNC_OPS.
  */
 
 import { getValues, getValue } from './resolve/getValues.js';
 import assignGingerly from './assignGingerly.js';
 import { resolveIdVariable, parseIdRef } from './resolve/resolveIdRef.js';
 import { processInferredAssignments } from './inferredAssignments.js';
+import { resolveLhsPath } from './utils/resolveLhsPath.js';
+import { SYNC_OPS } from './syncOps/registry.js';
 import type { PermissionProcessor, AssignFromOptions, AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 
 // Re-export types for consumers
@@ -49,6 +52,48 @@ export function parseTernaryCommand(key: string): string | null {
     return key.substring(0, key.length - 3); // Remove ' ?=' suffix
 }
 
+/**
+ * Check if a key ends with the sync-op operator ' =&'.
+ */
+export function isSyncOpCommand(key: string): boolean {
+    return key.endsWith(' =&');
+}
+
+/**
+ * Parse a =& sync-op command and extract the LHS path.
+ */
+export function parseSyncOpCommand(key: string): string | null {
+    if (!isSyncOpCommand(key)) return null;
+    return key.substring(0, key.length - 3); // Remove ' =&' suffix
+}
+
+/**
+ * Throws if a resolved sync-op value (or anything nested inside it) is a thenable.
+ *
+ * getValues is synchronous by contract, but `options.protocols` handlers are
+ * typed to allow returning a Promise. A sync op has no await to catch that —
+ * left unchecked it would silently stringify as "[object Promise]" — so this
+ * turns it into a clear error instead.
+ */
+function assertNoThenable(value: any, opName: string, key: string): void {
+    if (value == null) return;
+    if (typeof value.then === 'function') {
+        throw new Error(
+            `assignFrom: sync op '${opName}' (key "${key}") received an async value — ` +
+            `a protocol in options.protocols returned a Promise, which ' =&' cannot await. ` +
+            `Use ' =>' with 'resolve:' instead for async values.`
+        );
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) assertNoThenable(item, opName, key);
+    } else if (typeof value === 'object') {
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null) {
+            for (const item of Object.values(value)) assertNoThenable(item, opName, key);
+        }
+    }
+}
+
 /**
  * Resolve a single value — if it's a `?.` path string, resolve against source.
  * If it's a protocol string, resolve via protocol. Otherwise pass through as literal.
@@ -354,6 +399,7 @@ export function categorizeKeys(expandedPattern: Record<string, any>) {
   const idRefNormalKeys: string[] = [];
   const idRefHandlerKeys: string[] = [];
   const ternaryKeys: string[] = [];
+  const syncOpKeys: string[] = [];
 
   for (const key of Object.keys(expandedPattern)) {
     if (isHandlerCommand(key)) {
@@ -364,6 +410,8 @@ export function categorizeKeys(expandedPattern: Record<string, any>) {
       }
     } else if (isTernaryCommand(key)) {
       ternaryKeys.push(key);
+    } else if (isSyncOpCommand(key)) {
+      syncOpKeys.push(key);
     } else if (key.startsWith('#[')) {
       idRefNormalKeys.push(key);
     } else {
@@ -371,7 +419,7 @@ export function categorizeKeys(expandedPattern: Record<string, any>) {
     }
   }
 
-  return { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys };
+  return { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys, syncOpKeys };
 }
 
 /**
@@ -447,7 +495,7 @@ export function assignFrom(
   const expandedPattern = expandSubstitutions(pattern, options);
 
   // Categorize keys
-  const { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys } = categorizeKeys(expandedPattern);
+  const { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys, syncOpKeys } = categorizeKeys(expandedPattern);
 
   const resolveOptions = { ...options, root: target, permissionProcessor } as any;
 
@@ -469,6 +517,36 @@ export function assignFrom(
     }
   }
 
+  // Process =& sync-op keys (sync — always, no dynamic import, no await, ever)
+  if (syncOpKeys.length > 0) {
+    for (const key of syncOpKeys) {
+      const lhsPath = parseSyncOpCommand(key);
+      if (lhsPath === null) continue;
+      const config = expandedPattern[key];
+      if (!config || typeof config !== 'object' || Array.isArray(config)) {
+        throw new Error(`assignFrom: sync-op command "${key}" requires a config object naming exactly one op`);
+      }
+
+      const opName = Object.keys(config).find(k => k in SYNC_OPS);
+      if (!opName) {
+        throw new Error(`assignFrom: sync-op command "${key}" does not name a known op (${Object.keys(SYNC_OPS).join(', ')})`);
+      }
+
+      const resolvedConfig = getValues(config, options.from, resolveOptions);
+      assertNoThenable(resolvedConfig, opName, key);
+
+      const { [opName]: args, ...extra } = resolvedConfig;
+      const result = SYNC_OPS[opName](args, extra);
+      if (result === undefined) continue;
+
+      const { lhsParent, lhsKey } = resolveLhsPath(target, lhsPath, options);
+      if (lhsParent != null && lhsKey != null
+          && !permissionProcessor?.redirectRestrictedProp(lhsParent, lhsKey, result)) {
+        lhsParent[lhsKey] = result;
+      }
+    }
+  }
+
   // Process normal keys via getValues (sync) + assignGingerly
   if (Object.keys(normalPattern).length > 0) {
     // Resolve #[x] references on RHS values before getValues

package/inferencer/types/NewCustomElementFeature.md

@@ -224,7 +224,7 @@ Create `.vscode/settings.json`:
 }
 ```
 
-## Step 8: Set Up .kiro Directory
+## Step 8: Set Up .kiro Directory Only if kiro is implementing.
 
 Create `.kiro/steering/project-context.md` to reference the shared types documentation:
 
@@ -350,6 +350,8 @@ customElements.assignFeatures(MyElement, {
 
 The parsed attributes (`{ myProp: 'hello', count: 42 }`) are passed as `initVals` to the constructor.
 
+See [withAttrs](https://github.com/bahrus/assign-gingerly/blob/baseline/docs/withAttrs.md) for an in-depth discussion of all the various configuration options.
+
 ### Async Spawn (Lazy Loading)
 
 Feature implementations can be loaded asynchronously:

package/inferencer/types/NewHTMLFirstCustomElement.md

@@ -7,6 +7,8 @@
 
 - **[plus-minus](https://github.com/bahrus/plus-minus)** -- Expand / Collapse component - More robust examples of dynamic DOM manipulation with the help of roundabout configuration.  Also demonstrates use of the DX libraries to get typing intellisense help.
 
+- **[side-burger](https://github.com/bahrus/side-burger)** -- Side Drawer component with menu.  
+
 ## Step 4
 
 Add the following additional dependencies in package.json:
@@ -379,7 +381,7 @@ Work is underway to improve the DX a bit, but for now:
 
 ```JS
 {
-    delay:10, //milliseconds
+    delay:100, //milliseconds
     ifAllOf: ['expanded'],
     assign: {
         set($.querySelector('a').focus()).to({}),
@@ -387,6 +389,71 @@ Work is underway to improve the DX a bit, but for now:
 },
 ```
 
+## How can I set externally specified elements to inert?
+
+This is implemented with the [side-burger](https://github.com/bahrus/side-burger) custom element, to see the full context.
+
+Suppose we define a property on the custom element, "inertTarget" which allows the developer to specify css matches from the root document to set to inert when the sidebar is open.  
+
+```JS
+
+// kept separate because "smoothOver" destroys typechecking
+/** @type Merges<AP> */
+const merges = [
+    ...
+    {
+        ifAllOf: [props.clone, props.inertTarget, props.open],
+        ...doAssign(
+            set(props.inertTargetElements).to($.ownerDocument.querySelectorAll($.inertTarget)),
+            set($.inertTargetElements.Each.inert).to(true)
+        )
+    },
+    {
+        ifAllOf: [props.clone, props.inertTarget],
+        ifNoneOf: [props.open],
+        ...doAssign(
+            set($.inertTargetElements.Each.inert).to(false)
+        )
+    }
+];
+
+/** @type {AttrPatterns<AP>} */
+const withAttrs = {
+    ...
+    [props.inertTarget]: 'inert-target',
+    [`_${props.inertTarget}`]: {
+        mapsTo: props.inertTarget,
+    }
+}
+
+/**
+ * @type {RoundaboutOptions<AP, Actions, AP, 'click' | 'keydown'>}
+ */
+const raConfig = {
+    weakRef: {
+        ...
+        listProperties: [props.inertTargetElements],
+        ...
+    },
+    
+    assignOptions: {
+        akaMethods: {
+            ...
+            '🧺': m['🧺'], //querySelectorAll
+        },
+        substitutions: {
+            inertTarget: '?.inertTarget'
+        }
+    },
+    ...
+    merges: smoothOver(merges),
+    ...
+};
+```
+
+[Please fully digest all the attribute parsing tha assign-gingerly provides before configuring the attributes.](https://github.com/bahrus/assign-gingerly/blob/baseline/docs/withAttrs.md) 
+
+
 ## Step 8
 
 Run `node el-maker.mjs` (or `npm run build-el-maker` if your `package.json` includes a watch script) to regenerate `el-maker.json`.

package/inferencer/types/assign-gingerly/types.d.ts

@@ -112,6 +112,36 @@ export interface ParserContext<T = any> {
   attrName: string;
 }
 
+/**
+ * Tuple reference for custom element static method parsers
+ * [elementName, methodName]
+ */
+export type ParserTuple = [CustomElementName, CustomElementConstructorStaticMethodName];
+
+/**
+ * Class-based parser interface
+ * Classes registered as named parsers are instantiated per attribute parse
+ * and their parse method is called with the attribute value and context
+ */
+export interface AttrParser<T = any> {
+  parse(attrValue: string | null, context?: ParserContext<T>): any;
+}
+
+/**
+ * Constructor signature for class-based parsers
+ */
+export type AttrParserConstructor<T = any> = {
+  new (options?: any): AttrParser<T>;
+};
+
+/**
+ * Object form for referencing a registered named parser with constructor options
+ */
+export interface NamedParserRef {
+  name: string;
+  options?: any;
+}
+
 /**
  * Parser function signature
  * Can accept just the attribute value (simple form) or value + context (advanced form)
@@ -120,6 +150,15 @@ export type ParserFunction<T = any> =
   | ((attrValue: string | null) => any)
   | ((attrValue: string | null, context?: ParserContext<T>) => any);
 
+/**
+ * Any valid parser specification for AttrConfig.parser
+ */
+export type ParserSpec<T = any> =
+  | ParserFunction<T>
+  | string
+  | ParserTuple
+  | NamedParserRef;
+
 export interface AttrConfig<T = unknown, TParserConfig = unknown> {
   /**
    * Type of the property value (JSON-serializable string format)
@@ -148,7 +187,9 @@ export interface AttrConfig<T = unknown, TParserConfig = unknown> {
    * - Function: Inline parser function (not JSON serializable)
    *   - Simple form: (attrValue: string | null) => any
    *   - Advanced form: (attrValue: string | null, context: ParserContext) => any
-   * - String: Named parser reference (JSON serializable) - looks up in scoped registry (if available) then global parser registry (e.g., 'timestamp', 'csv')
+   * - String: Named parser reference (JSON serializable) - looks up in scoped registry (if available) then global parser registry (e.g., 'timestamp', 'splitter')
+   * - Tuple: [CustomElementName, StaticMethodName] - looks up a static method on a custom element constructor
+   * - Object: { name: string; options?: any } - looks up a registered class parser and instantiates it with the given options
    * 
    * Parser functions can optionally accept a second parameter (ParserContext) which provides:
    * - attrConfig: The full AttrConfig object for this attribute
@@ -156,10 +197,7 @@ export interface AttrConfig<T = unknown, TParserConfig = unknown> {
    * - element: The element being enhanced
    * - attrName: The resolved attribute name
    */
-  parser?: 
-    | ParserFunction<T>
-    | string
-  ;
+  parser?: ParserSpec<T>;
 
   /**
    * configuration information needed by a custom parser to properly

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.84",
+  "version": "0.0.86",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -22,6 +22,7 @@
     "handlers/**",
     "inferencer/**",
     "resolve/**",
+    "syncOps/**",
     "utils/**",
     "README.md",
     "LICENSE",
@@ -51,6 +52,10 @@
     "./parserRegistry.js": {
       "default": "./parserRegistry.js"
     },
+    "./SplitParser.js": {
+      "default": "./SplitParser.js",
+      "types": "./SplitParser.ts"
+    },
     "./parseWithAttrs.js": {
       "default": "./parseWithAttrs.js",
       "types": "./parseWithAttrs.ts"
@@ -99,9 +104,13 @@
       "default": "./handlers/lazyLoadSwitch.js",
       "types": "./handlers/lazyLoadSwitch.ts"
     },
-    "./handlers/join.js": {
-      "default": "./handlers/join.js",
-      "types": "./handlers/join.ts"
+    "./syncOps/join.js": {
+      "default": "./syncOps/join.js",
+      "types": "./syncOps/join.ts"
+    },
+    "./syncOps/registry.js": {
+      "default": "./syncOps/registry.js",
+      "types": "./syncOps/registry.ts"
     },
     "./handlers/microDataJoin.js": {
       "default": "./handlers/microDataJoin.js",