gonia 0.1.2 → 0.2.0

package/dist/directives/for.js

@@ -4,8 +4,8 @@
  * @packageDocumentation
  */
 import { directive, DirectivePriority, Mode } from '../types.js';
-import { effect, createEffectScope, createScope } from '../reactivity.js';
-import { createContext } from '../context.js';
+import { effect, createEffectScope } from '../reactivity.js';
+import { processElementTree } from '../process.js';
 /**
  * Parse a g-for expression.
  *
@@ -31,77 +31,10 @@ function parseForExpression(expr) {
 export const FOR_PROCESSED_ATTR = 'data-g-for-processed';
 /** Attribute used to mark template content that should be skipped during SSR */
 export const FOR_TEMPLATE_ATTR = 'data-g-for-template';
-/**
- * Process directives on a cloned element within a child scope.
- */
-function processClonedElement(el, parentState, scopeAdditions, mode) {
-    // Mark this element as processed by g-for so hydrate skips it
-    el.setAttribute(FOR_PROCESSED_ATTR, '');
-    const childScope = createScope(parentState, scopeAdditions);
-    const childCtx = createContext(mode, childScope);
-    // Process g-text directives
-    const textAttr = el.getAttribute('g-text');
-    if (textAttr) {
-        const value = childCtx.eval(textAttr);
-        el.textContent = String(value ?? '');
-    }
-    // Process g-class directives
-    const classAttr = el.getAttribute('g-class');
-    if (classAttr) {
-        const classObj = childCtx.eval(classAttr);
-        if (classObj && typeof classObj === 'object') {
-            for (const [className, shouldAdd] of Object.entries(classObj)) {
-                if (shouldAdd) {
-                    el.classList.add(className);
-                }
-                else {
-                    el.classList.remove(className);
-                }
-            }
-        }
-    }
-    // Process g-show directives
-    const showAttr = el.getAttribute('g-show');
-    if (showAttr) {
-        const value = childCtx.eval(showAttr);
-        el.style.display = value ? '' : 'none';
-    }
-    // Process g-on directives (format: "event: handler") - client only
-    if (mode === Mode.CLIENT) {
-        const onAttr = el.getAttribute('g-on');
-        if (onAttr) {
-            setupEventHandler(el, onAttr, childCtx, childScope);
-        }
-    }
-    // Process children recursively
-    for (const child of el.children) {
-        processClonedElement(child, childScope, {}, mode);
-    }
-}
-/**
- * Set up an event handler on an element.
- * Expression format: "event: handler"
- */
-function setupEventHandler(el, expr, ctx, state) {
-    const colonIdx = expr.indexOf(':');
-    if (colonIdx === -1) {
-        console.error(`Invalid g-on expression: ${expr}. Expected "event: handler"`);
-        return;
-    }
-    const eventName = expr.slice(0, colonIdx).trim();
-    const handlerExpr = expr.slice(colonIdx + 1).trim();
-    const handler = (event) => {
-        const result = ctx.eval(handlerExpr);
-        if (typeof result === 'function') {
-            result.call(state, event);
-        }
-    };
-    el.addEventListener(eventName, handler);
-}
 /**
  * Render loop items (used by both server and client).
  */
-function renderItems(template, parent, insertAfterNode, parsed, $eval, $state, mode) {
+function renderItems(template, parent, insertAfterNode, parsed, $eval, $scope, mode) {
     const { itemName, indexName, iterableName } = parsed;
     const iterable = $eval(iterableName);
     const renderedElements = [];
@@ -136,7 +69,10 @@ function renderItems(template, parent, insertAfterNode, parsed, $eval, $state, m
         if (indexName) {
             scopeAdditions[indexName] = key;
         }
-        processClonedElement(clone, $state, scopeAdditions, mode);
+        // Mark as processed
+        clone.setAttribute(FOR_PROCESSED_ATTR, '');
+        // Process with shared utility
+        processElementTree(clone, $scope, mode, { scopeAdditions });
         if (insertAfter.nextSibling) {
             parent.insertBefore(clone, insertAfter.nextSibling);
         }
@@ -177,7 +113,7 @@ function removeSSRItems(templateEl) {
  * <div g-for="(value, key) in object" g-text="key + ': ' + value"></div>
  * ```
  */
-export const cfor = function cfor($expr, $element, $eval, $state, $mode) {
+export const cfor = function cfor($expr, $element, $eval, $scope, $mode) {
     const parsed = parseForExpression($expr);
     if (!parsed) {
         console.error(`Invalid g-for expression: ${$expr}`);
@@ -204,7 +140,7 @@ export const cfor = function cfor($expr, $element, $eval, $state, $mode) {
         // Replace original with template wrapper
         parent.replaceChild(templateWrapper, $element);
         // Render items after the template
-        renderItems(templateContent, parent, templateWrapper, parsed, $eval, $state, $mode);
+        renderItems(templateContent, parent, templateWrapper, parsed, $eval, $scope, $mode);
         return;
     }
     // Client-side: check if hydrating from SSR or fresh render
@@ -230,7 +166,7 @@ export const cfor = function cfor($expr, $element, $eval, $state, $mode) {
             }
             scope = createEffectScope();
             scope.run(() => {
-                renderedElements = renderItems(templateContent, parent, templateWrapper, parsed, $eval, $state, Mode.CLIENT);
+                renderedElements = renderItems(templateContent, parent, templateWrapper, parsed, $eval, $scope, Mode.CLIENT);
             });
         });
     }
@@ -255,11 +191,11 @@ export const cfor = function cfor($expr, $element, $eval, $state, $mode) {
             }
             scope = createEffectScope();
             scope.run(() => {
-                renderedElements = renderItems(templateContent, parent, templateWrapper, parsed, $eval, $state, Mode.CLIENT);
+                renderedElements = renderItems(templateContent, parent, templateWrapper, parsed, $eval, $scope, Mode.CLIENT);
             });
         });
     }
 };
-cfor.$inject = ['$expr', '$element', '$eval', '$state', '$mode'];
+cfor.$inject = ['$expr', '$element', '$eval', '$scope', '$mode'];
 cfor.priority = DirectivePriority.STRUCTURAL;
 directive('g-for', cfor);

package/dist/directives/if.d.ts

@@ -13,6 +13,9 @@ export declare const IF_PROCESSED_ATTR = "data-g-if-processed";
  * Unlike g-show which uses display:none, g-if completely removes
  * the element from the DOM when the condition is falsy.
  *
+ * State within the conditional block is preserved across toggles.
+ * The scope is anchored to the placeholder, not the rendered element.
+ *
  * On server: evaluates once and removes element if false.
  * On client: sets up reactive effect to toggle element.
  *
@@ -22,4 +25,4 @@ export declare const IF_PROCESSED_ATTR = "data-g-if-processed";
  * <div g-if="items.length > 0">Has items</div>
  * ```
  */
-export declare const cif: Directive<['$expr', '$element', '$eval', '$state', '$mode']>;
+export declare const cif: Directive<['$expr', '$element', '$eval', '$scope', '$mode']>;

package/dist/directives/if.js

@@ -4,66 +4,30 @@
  * @packageDocumentation
  */
 import { directive, DirectivePriority, Mode } from '../types.js';
-import { effect } from '../reactivity.js';
-import { createContext } from '../context.js';
-import { createScope } from '../reactivity.js';
+import { effect, createScope } from '../reactivity.js';
+import { processElementTree } from '../process.js';
 /** Attribute used to mark elements processed by g-if */
 export const IF_PROCESSED_ATTR = 'data-g-if-processed';
+/** WeakMap to store persistent scopes for g-if placeholders */
+const placeholderScopes = new WeakMap();
 /**
- * Process directives on a conditionally rendered element.
+ * Get or create a persistent scope for a g-if placeholder.
+ *
+ * @remarks
+ * The scope is anchored to the placeholder element, not the rendered content.
+ * This allows state to persist across condition toggles.
+ *
+ * @param placeholder - The template placeholder element
+ * @param parentState - The parent scope to inherit from
+ * @returns The persistent scope for this g-if block
  */
-function processConditionalElement(el, parentState, mode) {
-    el.setAttribute(IF_PROCESSED_ATTR, '');
-    const childScope = createScope(parentState, {});
-    const childCtx = createContext(mode, childScope);
-    // Process g-text directives
-    const textAttr = el.getAttribute('g-text');
-    if (textAttr) {
-        const value = childCtx.eval(textAttr);
-        el.textContent = String(value ?? '');
-    }
-    // Process g-class directives
-    const classAttr = el.getAttribute('g-class');
-    if (classAttr) {
-        const classObj = childCtx.eval(classAttr);
-        if (classObj && typeof classObj === 'object') {
-            for (const [className, shouldAdd] of Object.entries(classObj)) {
-                if (shouldAdd) {
-                    el.classList.add(className);
-                }
-                else {
-                    el.classList.remove(className);
-                }
-            }
-        }
-    }
-    // Process g-show directives
-    const showAttr = el.getAttribute('g-show');
-    if (showAttr) {
-        const value = childCtx.eval(showAttr);
-        el.style.display = value ? '' : 'none';
-    }
-    // Process g-on directives (format: "event: handler") - client only
-    if (mode === Mode.CLIENT) {
-        const onAttr = el.getAttribute('g-on');
-        if (onAttr) {
-            const colonIdx = onAttr.indexOf(':');
-            if (colonIdx !== -1) {
-                const eventName = onAttr.slice(0, colonIdx).trim();
-                const handlerExpr = onAttr.slice(colonIdx + 1).trim();
-                el.addEventListener(eventName, (event) => {
-                    const result = childCtx.eval(handlerExpr);
-                    if (typeof result === 'function') {
-                        result.call(childScope, event);
-                    }
-                });
-            }
-        }
-    }
-    // Process children recursively
-    for (const child of el.children) {
-        processConditionalElement(child, childScope, mode);
+function getOrCreateScope(placeholder, parentState) {
+    let scope = placeholderScopes.get(placeholder);
+    if (!scope) {
+        scope = createScope(parentState, {});
+        placeholderScopes.set(placeholder, scope);
     }
+    return scope;
 }
 /**
  * Conditionally render an element.
@@ -72,6 +36,9 @@ function processConditionalElement(el, parentState, mode) {
  * Unlike g-show which uses display:none, g-if completely removes
  * the element from the DOM when the condition is falsy.
  *
+ * State within the conditional block is preserved across toggles.
+ * The scope is anchored to the placeholder, not the rendered element.
+ *
  * On server: evaluates once and removes element if false.
  * On client: sets up reactive effect to toggle element.
  *
@@ -81,37 +48,72 @@ function processConditionalElement(el, parentState, mode) {
  * <div g-if="items.length > 0">Has items</div>
  * ```
  */
-export const cif = function cif($expr, $element, $eval, $state, $mode) {
+export const cif = function cif($expr, $element, $eval, $scope, $mode) {
     const parent = $element.parentNode;
     if (!parent) {
         return;
     }
-    // Server-side: evaluate once and remove if false
+    // Server-side: evaluate once and leave template placeholder if false
     if ($mode === Mode.SERVER) {
         const condition = $eval($expr);
         if (!condition) {
+            // Leave a template marker so client hydration knows where to insert
+            const placeholder = $element.ownerDocument.createElement('template');
+            placeholder.setAttribute('data-g-if', String($expr));
+            // Store original element inside template for hydration
+            placeholder.innerHTML = $element.outerHTML;
+            parent.insertBefore(placeholder, $element);
             $element.remove();
         }
         else {
             // Process child directives
             $element.removeAttribute('g-if');
-            processConditionalElement($element, $state, $mode);
+            $element.setAttribute(IF_PROCESSED_ATTR, '');
+            processElementTree($element, $scope, $mode);
         }
         return;
     }
-    // Client-side: set up reactive effect
-    const placeholder = $element.ownerDocument.createComment(` g-if: ${$expr} `);
-    parent.insertBefore(placeholder, $element);
-    const template = $element.cloneNode(true);
-    template.removeAttribute('g-if');
-    $element.remove();
+    // Client-side: check if this is a template placeholder (from SSR)
+    const isTemplatePlaceholder = $element.tagName === 'TEMPLATE' && $element.hasAttribute('data-g-if');
+    let placeholder;
+    let template;
+    if (isTemplatePlaceholder) {
+        // Hydrating SSR output - template is the placeholder, content is inside
+        placeholder = $element;
+        const content = $element.content.firstElementChild
+            || $element.innerHTML;
+        if (typeof content === 'string') {
+            const temp = $element.ownerDocument.createElement('div');
+            temp.innerHTML = content;
+            template = temp.firstElementChild;
+        }
+        else {
+            template = content.cloneNode(true);
+        }
+        template.removeAttribute('g-if');
+    }
+    else {
+        // Pure client-side - create template placeholder
+        placeholder = $element.ownerDocument.createElement('template');
+        placeholder.setAttribute('data-g-if', String($expr));
+        parent.insertBefore(placeholder, $element);
+        template = $element.cloneNode(true);
+        template.removeAttribute('g-if');
+        $element.remove();
+    }
+    // Create persistent scope anchored to the placeholder
+    const persistentScope = getOrCreateScope(placeholder, $scope);
     let renderedElement = null;
     effect(() => {
         const condition = $eval($expr);
         if (condition) {
             if (!renderedElement) {
                 renderedElement = template.cloneNode(true);
-                processConditionalElement(renderedElement, $state, Mode.CLIENT);
+                renderedElement.setAttribute(IF_PROCESSED_ATTR, '');
+                // Process with the persistent scope - state survives across toggles
+                processElementTree(renderedElement, $scope, Mode.CLIENT, {
+                    existingScope: persistentScope
+                });
                 if (placeholder.nextSibling) {
                     parent.insertBefore(renderedElement, placeholder.nextSibling);
                 }
@@ -124,10 +126,11 @@ export const cif = function cif($expr, $element, $eval, $state, $mode) {
             if (renderedElement) {
                 renderedElement.remove();
                 renderedElement = null;
+                // Scope survives in persistentScope - ready for next render
             }
         }
     });
 };
-cif.$inject = ['$expr', '$element', '$eval', '$state', '$mode'];
+cif.$inject = ['$expr', '$element', '$eval', '$scope', '$mode'];
 cif.priority = DirectivePriority.STRUCTURAL;
 directive('g-if', cif);

package/dist/directives/slot.d.ts

@@ -9,12 +9,14 @@
  * @packageDocumentation
  */
 import { Directive } from '../types.js';
+import { SlotContentContext } from './template.js';
 /**
  * Slot directive for content transclusion.
  *
  * @remarks
  * Finds the nearest template ancestor and transcludes the
- * matching slot content into itself.
+ * matching slot content into itself. The SlotContentContext
+ * is automatically injected via DI.
  *
  * If the slot name is an expression, wraps in an effect
  * for reactivity.
@@ -35,7 +37,7 @@ import { Directive } from '../types.js';
  * <slot></slot>
  * ```
  */
-export declare const slot: Directive<['$expr', '$element', '$eval']>;
+export declare const slot: Directive<['$expr', '$element', '$eval', typeof SlotContentContext]>;
 /**
  * Process native <slot> elements.
  *

package/dist/directives/slot.js

@@ -10,13 +10,15 @@
  */
 import { directive } from '../types.js';
 import { effect } from '../reactivity.js';
-import { findTemplateAncestor, getSavedContent } from './template.js';
+import { resolveContext } from '../context-registry.js';
+import { SlotContentContext } from './template.js';
 /**
  * Slot directive for content transclusion.
  *
  * @remarks
  * Finds the nearest template ancestor and transcludes the
- * matching slot content into itself.
+ * matching slot content into itself. The SlotContentContext
+ * is automatically injected via DI.
  *
  * If the slot name is an expression, wraps in an effect
  * for reactivity.
@@ -37,7 +39,7 @@ import { findTemplateAncestor, getSavedContent } from './template.js';
  * <slot></slot>
  * ```
  */
-export const slot = function slot($expr, $element, $eval) {
+export const slot = function slot($expr, $element, $eval, $slotContent) {
     // Determine slot name
     // If expr is empty, check for name attribute, otherwise use 'default'
     const getName = () => {
@@ -50,16 +52,11 @@ export const slot = function slot($expr, $element, $eval) {
     };
     const transclude = () => {
         const name = getName();
-        const templateEl = findTemplateAncestor($element);
-        if (!templateEl) {
-            // No template ancestor - leave slot as-is or clear it
+        // SlotContentContext is injected via DI
+        if (!$slotContent) {
             return;
         }
-        const content = getSavedContent(templateEl);
-        if (!content) {
-            return;
-        }
-        const slotContent = content.slots.get(name);
+        const slotContent = $slotContent.slots.get(name);
         if (slotContent) {
             $element.innerHTML = slotContent;
         }
@@ -73,6 +70,7 @@ export const slot = function slot($expr, $element, $eval) {
         transclude();
     }
 };
+slot.$inject = ['$expr', '$element', '$eval', SlotContentContext];
 directive('g-slot', slot);
 /**
  * Process native <slot> elements.
@@ -85,11 +83,8 @@ directive('g-slot', slot);
  */
 export function processNativeSlot(el) {
     const name = el.getAttribute('name') ?? 'default';
-    const templateEl = findTemplateAncestor(el);
-    if (!templateEl) {
-        return;
-    }
-    const content = getSavedContent(templateEl);
+    // Resolve slot content from nearest template ancestor
+    const content = resolveContext(el, SlotContentContext);
     if (!content) {
         return;
     }

package/dist/directives/template.d.ts

@@ -10,15 +10,22 @@
  */
 import { Directive } from '../types.js';
 import { EffectScope } from '../reactivity.js';
+import { ContextKey } from '../context-registry.js';
 /**
  * Saved slot content for an element.
- *
- * @internal
  */
 export interface SlotContent {
     /** Content by slot name. 'default' for unnamed content. */
     slots: Map<string, string>;
 }
+/**
+ * Context key for slot content.
+ *
+ * @remarks
+ * Templates register their slot content using this context, and
+ * slot directives resolve it to find their content.
+ */
+export declare const SlotContentContext: ContextKey<SlotContent>;
 /**
  * Get saved slot content for an element.
  *

package/dist/directives/template.js

@@ -10,8 +10,16 @@
  */
 import { directive, DirectivePriority } from '../types.js';
 import { createEffectScope } from '../reactivity.js';
-/** WeakMap storing saved children per element. */
-const savedContent = new WeakMap();
+import { findAncestor } from '../dom.js';
+import { createContextKey, registerContext, resolveContext, hasContext } from '../context-registry.js';
+/**
+ * Context key for slot content.
+ *
+ * @remarks
+ * Templates register their slot content using this context, and
+ * slot directives resolve it to find their content.
+ */
+export const SlotContentContext = createContextKey('SlotContent');
 /** WeakMap storing effect scopes per element for cleanup. */
 const elementScopes = new WeakMap();
 /** Set tracking which templates are currently rendering (cycle detection). */
@@ -22,7 +30,7 @@ const renderingChain = new WeakMap();
  * @internal
  */
 export function getSavedContent(el) {
-    return savedContent.get(el);
+    return resolveContext(el, SlotContentContext, true);
 }
 /**
  * Find the nearest ancestor with saved content (the template element).
@@ -30,14 +38,7 @@ export function getSavedContent(el) {
  * @internal
  */
 export function findTemplateAncestor(el) {
-    let current = el.parentElement;
-    while (current) {
-        if (savedContent.has(current)) {
-            return current;
-        }
-        current = current.parentElement;
-    }
-    return null;
+    return findAncestor(el, (e) => hasContext(e, SlotContentContext) ? e : undefined) ?? null;
 }
 /**
  * Check if a node is an Element.
@@ -116,11 +117,11 @@ export const template = async function template($expr, $element, $templates) {
         console.error(`Cycle detected: template "${templateName}" is already being rendered`);
         return;
     }
-    // Save children for slots
+    // Save children for slots using typed context
     const slotContent = {
         slots: extractSlotContent($element)
     };
-    savedContent.set($element, slotContent);
+    registerContext($element, SlotContentContext, slotContent);
     // Track this template in the chain
     const newChain = new Set(chain);
     newChain.add(templateName);

package/dist/dom.d.ts

@@ -0,0 +1,29 @@
+/**
+ * DOM traversal utilities.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Find an ancestor element matching a predicate.
+ *
+ * @remarks
+ * Walks up the DOM tree starting from the element's parent (or the element
+ * itself if `includeSelf` is true), calling the predicate on each ancestor.
+ * Returns the first non-undefined result from the predicate.
+ *
+ * @typeParam T - The type returned by the predicate
+ * @param el - The element to start from
+ * @param predicate - Function called on each ancestor, returns a value or undefined
+ * @param includeSelf - Whether to check the element itself (default: false)
+ * @returns The first non-undefined result from the predicate, or undefined
+ *
+ * @example
+ * ```ts
+ * // Find ancestor with a specific attribute
+ * const ancestor = findAncestor(el, (e) => e.hasAttribute('data-scope') ? e : undefined);
+ *
+ * // Find value from a WeakMap on an ancestor
+ * const value = findAncestor(el, (e) => myWeakMap.get(e));
+ * ```
+ */
+export declare function findAncestor<T>(el: Element, predicate: (el: Element) => T | undefined, includeSelf?: boolean): T | undefined;

package/dist/dom.js

@@ -0,0 +1,39 @@
+/**
+ * DOM traversal utilities.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Find an ancestor element matching a predicate.
+ *
+ * @remarks
+ * Walks up the DOM tree starting from the element's parent (or the element
+ * itself if `includeSelf` is true), calling the predicate on each ancestor.
+ * Returns the first non-undefined result from the predicate.
+ *
+ * @typeParam T - The type returned by the predicate
+ * @param el - The element to start from
+ * @param predicate - Function called on each ancestor, returns a value or undefined
+ * @param includeSelf - Whether to check the element itself (default: false)
+ * @returns The first non-undefined result from the predicate, or undefined
+ *
+ * @example
+ * ```ts
+ * // Find ancestor with a specific attribute
+ * const ancestor = findAncestor(el, (e) => e.hasAttribute('data-scope') ? e : undefined);
+ *
+ * // Find value from a WeakMap on an ancestor
+ * const value = findAncestor(el, (e) => myWeakMap.get(e));
+ * ```
+ */
+export function findAncestor(el, predicate, includeSelf = false) {
+    let current = includeSelf ? el : el.parentElement;
+    while (current) {
+        const result = predicate(current);
+        if (result !== undefined) {
+            return result;
+        }
+        current = current.parentElement;
+    }
+    return undefined;
+}

package/dist/expression.js

@@ -43,8 +43,23 @@ export function findRoots(expr) {
         .replace(/'(?:[^'\\]|\\.)*'/g, '""')
         .replace(/"(?:[^"\\]|\\.)*"/g, '""')
         .replace(/`(?:[^`\\$]|\\.|\$(?!\{))*`/g, '""');
-    const matches = cleaned.match(/(?<![.\w$])\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g) || [];
-    const roots = [...new Set(matches.filter(m => !JS_KEYWORDS.has(m)))];
+    // Match identifiers that are not preceded by a dot
+    // Use simpler approach: match all identifiers, then filter out property accesses
+    const allIdentifiers = cleaned.match(/[a-zA-Z_$][a-zA-Z0-9_$]*/g) || [];
+    // Filter to keep only root identifiers (not after a dot)
+    const roots = [];
+    let lastEnd = 0;
+    for (const id of allIdentifiers) {
+        const pos = cleaned.indexOf(id, lastEnd);
+        // Check if preceded by a dot (with optional whitespace)
+        const before = cleaned.slice(0, pos).trimEnd();
+        if (!before.endsWith('.')) {
+            if (!JS_KEYWORDS.has(id) && !roots.includes(id)) {
+                roots.push(id);
+            }
+        }
+        lastEnd = pos + id.length;
+    }
     return roots;
 }
 /**

package/dist/index.d.ts

@@ -7,7 +7,7 @@
  *
  * @packageDocumentation
  */
-export { Mode, Expression, Context, Directive, directive, getDirective, getDirectiveNames, clearDirectives } from './types.js';
+export { Mode, Expression, Context, Directive, directive, getDirective, getDirectiveNames, clearDirectives, configureDirective } from './types.js';
 export type { DirectiveMeta } from './types.js';
 export { createContext, createChildContext } from './context.js';
 export { reactive, effect, createScope, createEffectScope } from './reactivity.js';
@@ -15,6 +15,12 @@ export type { EffectScope } from './reactivity.js';
 export { createTemplateRegistry, createMemoryRegistry, createServerRegistry } from './templates.js';
 export type { TemplateRegistry } from './templates.js';
 export { findRoots, parseInterpolation } from './expression.js';
-export { getInjectables } from './inject.js';
+export { getInjectables, isContextKey } from './inject.js';
+export type { Injectable } from './inject.js';
 export { getRootScope, clearRootScope } from './scope.js';
+export { findAncestor } from './dom.js';
+export { processElementDirectives, processElementTree, PROCESSED_ATTR } from './process.js';
+export type { ProcessOptions } from './process.js';
+export { createContextKey, registerContext, resolveContext, hasContext, removeContext, clearContexts } from './context-registry.js';
+export type { ContextKey } from './context-registry.js';
 export * as directives from './directives/index.js';

package/dist/index.js

@@ -7,11 +7,14 @@
  *
  * @packageDocumentation
  */
-export { Mode, directive, getDirective, getDirectiveNames, clearDirectives } from './types.js';
+export { Mode, directive, getDirective, getDirectiveNames, clearDirectives, configureDirective } from './types.js';
 export { createContext, createChildContext } from './context.js';
 export { reactive, effect, createScope, createEffectScope } from './reactivity.js';
 export { createTemplateRegistry, createMemoryRegistry, createServerRegistry } from './templates.js';
 export { findRoots, parseInterpolation } from './expression.js';
-export { getInjectables } from './inject.js';
+export { getInjectables, isContextKey } from './inject.js';
 export { getRootScope, clearRootScope } from './scope.js';
+export { findAncestor } from './dom.js';
+export { processElementDirectives, processElementTree, PROCESSED_ATTR } from './process.js';
+export { createContextKey, registerContext, resolveContext, hasContext, removeContext, clearContexts } from './context-registry.js';
 export * as directives from './directives/index.js';