assign-gingerly 0.0.79 → 0.0.81

package/assignGingerly.js

@@ -420,6 +420,7 @@ export function isAllowedMethod(methodName, withMethods, permissionProcessor) {
 export function evaluatePathWithMethods(target, pathParts, value, withMethods, permissionProcessor) {
     let current = target;
     let i = 0;
+    let lastSegmentConsumed = false;
     // Process all segments except the last one
     while (i < pathParts.length - 1) {
         const part = pathParts[i];
@@ -442,6 +443,9 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods, p
                     // Only current is method - call with next part as string arg
                     current = method.call(current, nextPart, ...appendArgs);
                     i++; // Skip next part since we consumed it as argument
+                    if (i === pathParts.length - 1) {
+                        lastSegmentConsumed = true;
+                    }
                 }
             }
             else {
@@ -470,7 +474,8 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods, p
         target: current,
         lastKey,
         isMethod: isAllowedMethod(lastKey, withMethods, permissionProcessor),
-        isZeroArg
+        isZeroArg,
+        lastSegmentConsumed
     };
 }
 /**
@@ -623,6 +628,95 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
         }
     }
 }
+/**
+ * Resolve the RHS of a toggle (=!) command to the value that should be negated.
+ * Supports:
+ * - '?.path' nested path strings resolved against target (returns the resolved value, or true if missing)
+ * - plain key strings looked up on target (returns the value, or true if missing)
+ * - resolved literal values (e.g., booleans from assignFrom) returned as-is
+ */
+function resolveValueToNegate(rhsPath, target) {
+    if (typeof rhsPath === 'string' && isNestedPath(rhsPath)) {
+        const rhsPathParts = parsePath(rhsPath);
+        let current = target;
+        let exists = true;
+        for (const part of rhsPathParts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                exists = false;
+                break;
+            }
+        }
+        return exists ? current : true;
+    }
+    if (typeof rhsPath === 'string') {
+        return (rhsPath in target) ? target[rhsPath] : true;
+    }
+    // Non-string resolved value (e.g., boolean, number, null from assignFrom)
+    return rhsPath;
+}
+/**
+ * Navigate a path that leads to an iterable, returning the iterable value or undefined.
+ * Handles withMethods and the evaluatePathWithMethods semantics.
+ */
+function getIterableAtPath(target, pathParts, value, withMethods, permissionProcessor) {
+    let current = target;
+    if (pathParts.length > 0) {
+        if (withMethods && withMethods.size > 0) {
+            const result = evaluatePathWithMethods(target, pathParts, value, withMethods, permissionProcessor);
+            // evaluatePathWithMethods returns the container object + last key by default.
+            // If the last segment was consumed as a method argument, or the last segment
+            // is a zero-arg method marked with |, result.target is already the value.
+            if (result.lastSegmentConsumed) {
+                current = result.target;
+            }
+            else if (result.isMethod) {
+                const method = result.target[result.lastKey];
+                if (typeof method === 'function') {
+                    const appendArgs = permissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
+                    current = method.call(result.target, ...appendArgs);
+                }
+                else {
+                    current = method;
+                }
+            }
+            else {
+                current = result.target[result.lastKey];
+            }
+        }
+        else {
+            for (const part of pathParts) {
+                current = current[part];
+            }
+        }
+    }
+    return isIterable(current) ? current : undefined;
+}
+/**
+ * Apply an operator command (+=, =!, -=, Y=) to each item in an iterable.
+ * Detects @each in the path, navigates to the iterable, then builds a synthetic
+ * command key for the remaining path and delegates to assignGingerly per item.
+ * Nested @each is handled recursively through assignGingerly.
+ */
+function applyCommandToEach(target, pathParts, commandSuffix, value, withMethods, aliasMap, options, permissionProcessor) {
+    const forEachIndex = pathParts.findIndex(part => isForEachSymbol(part, aliasMap));
+    if (forEachIndex === -1)
+        return;
+    const pathToForEach = pathParts.slice(0, forEachIndex);
+    const pathAfterForEach = pathParts.slice(forEachIndex + 1);
+    const iterable = getIterableAtPath(target, pathToForEach, value, withMethods, permissionProcessor);
+    if (!iterable)
+        return;
+    const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
+    const syntheticKey = pathAfterForEach.length > 0
+        ? `?.${pathAfterForEach.join('?.')}${commandSuffix}`
+        : commandSuffix;
+    for (const item of items) {
+        assignGingerly(item, { [syntheticKey]: value }, options, permissionProcessor);
+    }
+}
 /**
  * Apply alias substitutions to a key string.
  * Replaces complete tokens between `?.` delimiters with their aliased values.
@@ -727,6 +821,11 @@ export function assignGingerly(target, source, options, permissionProcessor) {
             if (path) {
                 if (isNestedPath(path)) {
                     const pathParts = parsePath(path);
+                    // Check for @each in path
+                    if (pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+                        applyCommandToEach(target, pathParts, ' +=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+                        continue;
+                    }
                     // Check for withMethods path evaluation
                     let lhsValue;
                     let lhsParent;
@@ -795,54 +894,47 @@ export function assignGingerly(target, source, options, permissionProcessor) {
             const lhsPath = parseToggleCommand(key);
             if (lhsPath) {
                 const rhsPath = value;
-                // Resolve LHS
-                let lhsParent;
-                let lhsLastKey;
                 if (isNestedPath(lhsPath)) {
                     const lhsPathParts = parsePath(lhsPath);
-                    lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
-                    lhsParent = ensureNestedPath(target, lhsPathParts);
-                }
-                else {
-                    lhsLastKey = lhsPath;
-                    lhsParent = target;
-                }
-                // Determine what to negate
-                let valueToNegate;
-                if (rhsPath === '.') {
-                    // Self-reference: negate the LHS value itself (if it exists)
-                    if (lhsLastKey in lhsParent) {
-                        valueToNegate = lhsParent[lhsLastKey];
+                    // Check for @each in the LHS path
+                    if (lhsPathParts.some(part => isForEachSymbol(part, aliasMap))) {
+                        // Resolve non-self-referencing RHS paths against the original target
+                        // before iterating, so each item negates the same root value.
+                        const resolvedValue = (rhsPath === '.' || typeof rhsPath !== 'string')
+                            ? rhsPath
+                            : resolveValueToNegate(rhsPath, target);
+                        applyCommandToEach(target, lhsPathParts, ' =!', resolvedValue, withMethodsSet, aliasMap, options, permissionProcessor);
+                        continue;
+                    }
+                    // No @each in path - standard toggle
+                    const lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
+                    const lhsParent = ensureNestedPath(target, lhsPathParts);
+                    // Determine what to negate
+                    let valueToNegate;
+                    if (rhsPath === '.') {
+                        valueToNegate = (lhsLastKey in lhsParent) ? lhsParent[lhsLastKey] : undefined;
                     }
                     else {
-                        valueToNegate = undefined;
+                        valueToNegate = resolveValueToNegate(rhsPath, target);
+                    }
+                    if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
+                        lhsParent[lhsLastKey] = !valueToNegate;
                     }
                 }
                 else {
-                    // RHS path: navigate to get the value (don't create paths)
-                    if (isNestedPath(rhsPath)) {
-                        const rhsPathParts = parsePath(rhsPath);
-                        let current = target;
-                        let exists = true;
-                        for (const part of rhsPathParts) {
-                            if (current && typeof current === 'object' && part in current) {
-                                current = current[part];
-                            }
-                            else {
-                                exists = false;
-                                break;
-                            }
-                        }
-                        valueToNegate = exists ? current : true;
+                    // Plain key LHS
+                    const lhsLastKey = lhsPath;
+                    const lhsParent = target;
+                    let valueToNegate;
+                    if (rhsPath === '.') {
+                        valueToNegate = (lhsLastKey in lhsParent) ? lhsParent[lhsLastKey] : undefined;
                     }
                     else {
-                        // Plain key RHS
-                        valueToNegate = (rhsPath in target) ? target[rhsPath] : true;
+                        valueToNegate = resolveValueToNegate(rhsPath, target);
+                    }
+                    if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
+                        lhsParent[lhsLastKey] = !valueToNegate;
                     }
-                }
-                // Apply negation to LHS — check restriction first
-                if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
-                    lhsParent[lhsLastKey] = !valueToNegate;
                 }
             }
             continue;
@@ -856,6 +948,11 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                 let canDelete = true;
                 if (isNestedPath(path)) {
                     const pathParts = parsePath(path);
+                    // Check for @each in path
+                    if (pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+                        applyCommandToEach(target, pathParts, ' -=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+                        continue;
+                    }
                     if (pathParts.length === 0) {
                         parent = target;
                     }
@@ -901,6 +998,11 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                 if (permissionProcessor?.checkRestrictedProp(lastKey)) {
                     continue;
                 }
+                // Check for @each in path
+                if (isNestedPath(path) && pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+                    applyCommandToEach(target, pathParts, ' Y=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+                    continue;
+                }
                 // Navigate to the target sub-object
                 let mergeTarget;
                 if (isNestedPath(path)) {
@@ -956,22 +1058,9 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                 const pathToForEach = pathParts.slice(0, forEachIndex);
                 const pathAfterForEach = pathParts.slice(forEachIndex + 1);
                 // Navigate to the iterable
-                let current = target;
-                if (pathToForEach.length > 0) {
-                    if (withMethodsSet) {
-                        const result = evaluatePathWithMethods(target, pathToForEach, value, withMethodsSet, permissionProcessor);
-                        // The result.target is the current position after evaluating the path
-                        // This is already the iterable we want
-                        current = result.target;
-                    }
-                    else {
-                        for (const part of pathToForEach) {
-                            current = current[part];
-                        }
-                    }
-                }
+                const current = getIterableAtPath(target, pathToForEach, value, withMethodsSet, permissionProcessor);
                 // Apply to each item in the iterable
-                if (isIterable(current)) {
+                if (current) {
                     applyToEach(current, pathAfterForEach, value, withMethodsSet || new Set(), aliasMap, options, permissionProcessor);
                 }
                 // If not iterable, let JavaScript throw error naturally when trying to iterate

package/assignGingerly.ts

@@ -506,9 +506,10 @@ export function evaluatePathWithMethods(
   value: any,
   withMethods: Set<string>,
   permissionProcessor?: PermissionProcessor
-): { target: any; lastKey: string; isMethod: boolean; isZeroArg: boolean } {
+): { target: any; lastKey: string; isMethod: boolean; isZeroArg: boolean; lastSegmentConsumed: boolean } {
   let current = target;
   let i = 0;
+  let lastSegmentConsumed = false;
   
   // Process all segments except the last one
   while (i < pathParts.length - 1) {
@@ -533,6 +534,9 @@ export function evaluatePathWithMethods(
           // Only current is method - call with next part as string arg
           current = method.call(current, nextPart, ...appendArgs);
           i++; // Skip next part since we consumed it as argument
+          if (i === pathParts.length - 1) {
+            lastSegmentConsumed = true;
+          }
         }
       } else {
         // Not a function - just access property (create if needed)
@@ -561,7 +565,8 @@ export function evaluatePathWithMethods(
     target: current,
     lastKey,
     isMethod: isAllowedMethod(lastKey, withMethods, permissionProcessor),
-    isZeroArg
+    isZeroArg,
+    lastSegmentConsumed
   };
 }
 
@@ -724,6 +729,110 @@ function applyToEach(
   }
 }
 
+/**
+ * Resolve the RHS of a toggle (=!) command to the value that should be negated.
+ * Supports:
+ * - '?.path' nested path strings resolved against target (returns the resolved value, or true if missing)
+ * - plain key strings looked up on target (returns the value, or true if missing)
+ * - resolved literal values (e.g., booleans from assignFrom) returned as-is
+ */
+function resolveValueToNegate(rhsPath: any, target: any): any {
+  if (typeof rhsPath === 'string' && isNestedPath(rhsPath)) {
+    const rhsPathParts = parsePath(rhsPath);
+    let current = target;
+    let exists = true;
+    for (const part of rhsPathParts) {
+      if (current && typeof current === 'object' && part in current) {
+        current = current[part];
+      } else {
+        exists = false;
+        break;
+      }
+    }
+    return exists ? current : true;
+  }
+  if (typeof rhsPath === 'string') {
+    return (rhsPath in target) ? target[rhsPath] : true;
+  }
+  // Non-string resolved value (e.g., boolean, number, null from assignFrom)
+  return rhsPath;
+}
+
+/**
+ * Navigate a path that leads to an iterable, returning the iterable value or undefined.
+ * Handles withMethods and the evaluatePathWithMethods semantics.
+ */
+function getIterableAtPath(
+  target: any,
+  pathParts: string[],
+  value: any,
+  withMethods: Set<string> | undefined,
+  permissionProcessor?: PermissionProcessor
+): any {
+  let current = target;
+  if (pathParts.length > 0) {
+    if (withMethods && withMethods.size > 0) {
+      const result = evaluatePathWithMethods(target, pathParts, value, withMethods, permissionProcessor);
+      // evaluatePathWithMethods returns the container object + last key by default.
+      // If the last segment was consumed as a method argument, or the last segment
+      // is a zero-arg method marked with |, result.target is already the value.
+      if (result.lastSegmentConsumed) {
+        current = result.target;
+      } else if (result.isMethod) {
+        const method = result.target[result.lastKey];
+        if (typeof method === 'function') {
+          const appendArgs = permissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
+          current = method.call(result.target, ...appendArgs);
+        } else {
+          current = method;
+        }
+      } else {
+        current = result.target[result.lastKey];
+      }
+    } else {
+      for (const part of pathParts) {
+        current = current[part];
+      }
+    }
+  }
+  return isIterable(current) ? current : undefined;
+}
+
+/**
+ * Apply an operator command (+=, =!, -=, Y=) to each item in an iterable.
+ * Detects @each in the path, navigates to the iterable, then builds a synthetic
+ * command key for the remaining path and delegates to assignGingerly per item.
+ * Nested @each is handled recursively through assignGingerly.
+ */
+function applyCommandToEach(
+  target: any,
+  pathParts: string[],
+  commandSuffix: string,
+  value: any,
+  withMethods: Set<string> | undefined,
+  aliasMap: Map<string, string>,
+  options?: IAssignGingerlyOptions,
+  permissionProcessor?: PermissionProcessor
+): void {
+  const forEachIndex = pathParts.findIndex(part => isForEachSymbol(part, aliasMap));
+  if (forEachIndex === -1) return;
+
+  const pathToForEach = pathParts.slice(0, forEachIndex);
+  const pathAfterForEach = pathParts.slice(forEachIndex + 1);
+
+  const iterable = getIterableAtPath(target, pathToForEach, value, withMethods, permissionProcessor);
+  if (!iterable) return;
+
+  const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
+  const syntheticKey = pathAfterForEach.length > 0
+    ? `?.${pathAfterForEach.join('?.')}${commandSuffix}`
+    : commandSuffix;
+
+  for (const item of items) {
+    assignGingerly(item, { [syntheticKey]: value }, options, permissionProcessor);
+  }
+}
+
 /**
  * Apply alias substitutions to a key string.
  * Replaces complete tokens between `?.` delimiters with their aliased values.
@@ -845,6 +954,12 @@ export function assignGingerly(
         if (isNestedPath(path)) {
           const pathParts = parsePath(path);
 
+          // Check for @each in path
+          if (pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+            applyCommandToEach(target, pathParts, ' +=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+            continue;
+          }
+
           // Check for withMethods path evaluation
           let lhsValue: any;
           let lhsParent: any;
@@ -915,52 +1030,51 @@ export function assignGingerly(
       const lhsPath = parseToggleCommand(key);
       if (lhsPath) {
         const rhsPath = value;
-        
-        // Resolve LHS
-        let lhsParent: any;
-        let lhsLastKey: string;
+
         if (isNestedPath(lhsPath)) {
           const lhsPathParts = parsePath(lhsPath);
-          lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
-          lhsParent = ensureNestedPath(target, lhsPathParts);
-        } else {
-          lhsLastKey = lhsPath;
-          lhsParent = target;
-        }
 
-        // Determine what to negate
-        let valueToNegate;
-        if (rhsPath === '.') {
-          // Self-reference: negate the LHS value itself (if it exists)
-          if (lhsLastKey in lhsParent) {
-            valueToNegate = lhsParent[lhsLastKey];
+          // Check for @each in the LHS path
+          if (lhsPathParts.some(part => isForEachSymbol(part, aliasMap))) {
+            // Resolve non-self-referencing RHS paths against the original target
+            // before iterating, so each item negates the same root value.
+            const resolvedValue = (rhsPath === '.' || typeof rhsPath !== 'string')
+              ? rhsPath
+              : resolveValueToNegate(rhsPath, target);
+            applyCommandToEach(target, lhsPathParts, ' =!', resolvedValue, withMethodsSet, aliasMap, options, permissionProcessor);
+            continue;
+          }
+
+          // No @each in path - standard toggle
+          const lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
+          const lhsParent = ensureNestedPath(target, lhsPathParts);
+
+          // Determine what to negate
+          let valueToNegate: any;
+          if (rhsPath === '.') {
+            valueToNegate = (lhsLastKey in lhsParent) ? lhsParent[lhsLastKey] : undefined;
           } else {
-            valueToNegate = undefined;
+            valueToNegate = resolveValueToNegate(rhsPath, target);
+          }
+
+          if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
+            lhsParent[lhsLastKey] = !valueToNegate;
           }
         } else {
-          // RHS path: navigate to get the value (don't create paths)
-          if (isNestedPath(rhsPath)) {
-            const rhsPathParts = parsePath(rhsPath);
-            let current = target;
-            let exists = true;
-            for (const part of rhsPathParts) {
-              if (current && typeof current === 'object' && part in current) {
-                current = current[part];
-              } else {
-                exists = false;
-                break;
-              }
-            }
-            valueToNegate = exists ? current : true;
+          // Plain key LHS
+          const lhsLastKey = lhsPath;
+          const lhsParent = target;
+
+          let valueToNegate: any;
+          if (rhsPath === '.') {
+            valueToNegate = (lhsLastKey in lhsParent) ? lhsParent[lhsLastKey] : undefined;
           } else {
-            // Plain key RHS
-            valueToNegate = (rhsPath in target) ? target[rhsPath] : true;
+            valueToNegate = resolveValueToNegate(rhsPath, target);
+          }
+
+          if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
+            lhsParent[lhsLastKey] = !valueToNegate;
           }
-        }
-        
-        // Apply negation to LHS — check restriction first
-        if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
-          lhsParent[lhsLastKey] = !valueToNegate;
         }
       }
       continue;
@@ -976,6 +1090,13 @@ export function assignGingerly(
         
         if (isNestedPath(path)) {
           const pathParts = parsePath(path);
+
+          // Check for @each in path
+          if (pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+            applyCommandToEach(target, pathParts, ' -=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+            continue;
+          }
+
           if (pathParts.length === 0) {
             parent = target;
           } else {
@@ -1019,6 +1140,13 @@ export function assignGingerly(
         if (permissionProcessor?.checkRestrictedProp(lastKey)) {
           continue;
         }
+
+        // Check for @each in path
+        if (isNestedPath(path) && pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+          applyCommandToEach(target, pathParts, ' Y=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+          continue;
+        }
+
         // Navigate to the target sub-object
         let mergeTarget: any;
         if (isNestedPath(path)) {
@@ -1086,24 +1214,12 @@ export function assignGingerly(
         // Static forEach (@each) - existing logic
         const pathToForEach = pathParts.slice(0, forEachIndex);
         const pathAfterForEach = pathParts.slice(forEachIndex + 1);
-        
+
         // Navigate to the iterable
-        let current = target;
-        if (pathToForEach.length > 0) {
-          if (withMethodsSet) {
-            const result = evaluatePathWithMethods(target, pathToForEach, value, withMethodsSet, permissionProcessor);
-            // The result.target is the current position after evaluating the path
-            // This is already the iterable we want
-            current = result.target;
-          } else {
-            for (const part of pathToForEach) {
-              current = current[part];
-            }
-          }
-        }
-        
+        const current = getIterableAtPath(target, pathToForEach, value, withMethodsSet, permissionProcessor);
+
         // Apply to each item in the iterable
-        if (isIterable(current)) {
+        if (current) {
           applyToEach(current, pathAfterForEach, value, withMethodsSet || new Set(), aliasMap, options, permissionProcessor);
         }
         // If not iterable, let JavaScript throw error naturally when trying to iterate

package/handleIshProperty.js

@@ -47,7 +47,7 @@ async function defineIshProperty(element, managerName, options, assignGingerlyFn
     let config = registry.get(managerName);
     // If not registered, wait for registration
     if (!config) {
-        const { waitForEvent } = await import('./waitForEvent.js');
+        const { waitForEvent } = await import('./utils/waitForEvent.js');
         await waitForEvent(registry, managerName);
         config = registry.get(managerName);
         if (!config) {

package/handleIshProperty.ts

@@ -66,7 +66,7 @@ async function defineIshProperty(
 
   // If not registered, wait for registration
   if (!config) {
-    const { waitForEvent } = await import('./waitForEvent.js');
+    const { waitForEvent } = await import('./utils/waitForEvent.js');
     await waitForEvent(registry, managerName);
     config = registry.get(managerName);
     

package/handlers/manageTemplateList.js

@@ -224,7 +224,7 @@ export class ManageTemplateListHandler {
         if (fragment.childNodes.length > 0) {
             const waitOpt = resolvedParams.waitForSettled;
             if (waitOpt) {
-                const { waitForSettled } = await import('../waitForSettled.js');
+                const { waitForSettled } = await import('../utils/waitForSettled.js');
                 const idleMs = typeof waitOpt === 'object' ? waitOpt.idleMs : 100;
                 const timeout = typeof waitOpt === 'object' ? waitOpt.timeout : undefined;
                 try {

package/handlers/manageTemplateList.ts

@@ -263,7 +263,7 @@ export class ManageTemplateListHandler implements AssignFromHandler {
         if (fragment.childNodes.length > 0) {
             const waitOpt = resolvedParams.waitForSettled;
             if (waitOpt) {
-                const { waitForSettled } = await import('../waitForSettled.js');
+                const { waitForSettled } = await import('../utils/waitForSettled.js');
                 const idleMs = typeof waitOpt === 'object' ? waitOpt.idleMs : 100;
                 const timeout = typeof waitOpt === 'object' ? waitOpt.timeout : undefined;
                 try {

package/index.js

@@ -1,7 +1,7 @@
 export { assignGingerly } from './assignGingerly.js';
 export { assignTentatively } from './assignTentatively.js';
 export { EnhancementRegistry, ItemscopeRegistry, EnhancementRegisteredEvent } from './assignGingerly.js';
-export { waitForEvent } from './waitForEvent.js';
+export { waitForEvent } from './utils/waitForEvent.js';
 export { ParserRegistry, globalParserRegistry } from './parserRegistry.js';
 export { parseWithAttrs } from './parseWithAttrs.js';
 export { buildCSSQuery } from './buildCSSQuery.js';

package/index.ts

@@ -1,7 +1,7 @@
 export {assignGingerly} from './assignGingerly.js';
 export {assignTentatively} from './assignTentatively.js';
 export {EnhancementRegistry, ItemscopeRegistry, EnhancementRegisteredEvent} from './assignGingerly.js';
-export {waitForEvent} from './waitForEvent.js';
+export {waitForEvent} from './utils/waitForEvent.js';
 export {ParserRegistry, globalParserRegistry} from './parserRegistry.js';
 export {parseWithAttrs} from './parseWithAttrs.js';
 export {buildCSSQuery} from './buildCSSQuery.js';