@vertz/ui 0.2.15 → 0.2.16

package/dist/shared/{chunk-nn9v1zmk.js → chunk-b0qqqk03.js}

@@ -1,7 +1,15 @@
 import {
-  __classList,
+  __classList
+} from "./chunk-1rxa2fz4.js";
+import {
+  RouterContext
+} from "./chunk-mtsvrj9e.js";
+import {
   __on
-} from "./chunk-dksg08fq.js";
+} from "./chunk-pnv25zep.js";
+import {
+  isBrowser
+} from "./chunk-14eqne2a.js";
 import {
   __append,
   __element,
@@ -9,18 +17,19 @@ import {
   __exitChildren,
   __staticText,
   getIsHydrating
-} from "./chunk-j6qyxfdc.js";
+} from "./chunk-vndfjfdy.js";
 import {
   _tryOnCleanup,
   createContext,
   domEffect,
+  getSSRContext,
   popScope,
   pushScope,
   runCleanups,
   signal,
   untrack,
   useContext
-} from "./chunk-8hsz5y4a.js";
+} from "./chunk-4fwcwxn6.js";
 
 // src/router/link.ts
 var DANGEROUS_SCHEMES = ["javascript:", "data:", "vbscript:"];
@@ -65,8 +74,10 @@ function createLink(currentPath, navigate, factoryOptions) {
       } else {
         __append(el, result);
       }
-    } else {
+    } else if (typeof children === "string") {
       __append(el, __staticText(children));
+    } else {
+      __append(el, children);
     }
     __exitChildren();
     if (activeClass) {
@@ -88,22 +99,49 @@ function createLink(currentPath, navigate, factoryOptions) {
     return el;
   };
 }
-
-// src/router/router-context.ts
-var RouterContext = createContext(undefined, "@vertz/ui::RouterContext");
-function useRouter() {
+function Link({ href, children, activeClass, className }) {
   const router = useContext(RouterContext);
   if (!router) {
-    throw new Error("useRouter() must be called within RouterContext.Provider");
+    throw new Error("Link must be used within a RouterContext.Provider (via createRouter)");
   }
-  return router;
-}
-function useParams() {
-  const router = useContext(RouterContext);
-  if (!router) {
-    throw new Error("useParams() must be called within RouterContext.Provider");
+  const safeHref = isSafeUrl(href) ? href : "#";
+  const handleClick = (event) => {
+    const mouseEvent = event;
+    if (mouseEvent.ctrlKey || mouseEvent.metaKey || mouseEvent.shiftKey || mouseEvent.altKey) {
+      return;
+    }
+    mouseEvent.preventDefault();
+    router.navigate({ to: safeHref });
+  };
+  const props = { href: safeHref };
+  if (className) {
+    props.class = className;
   }
-  return router.current?.parsedParams ?? router.current?.params ?? {};
+  const el = __element("a", props);
+  __on(el, "click", handleClick);
+  __enterChildren(el);
+  if (typeof children === "function") {
+    const result = children();
+    if (typeof result === "string") {
+      __append(el, __staticText(result));
+    } else {
+      __append(el, result);
+    }
+  } else if (typeof children === "string") {
+    __append(el, __staticText(children));
+  } else {
+    __append(el, children);
+  }
+  __exitChildren();
+  if (activeClass) {
+    __classList(el, {
+      [activeClass]: () => {
+        router.current;
+        return isBrowser() ? window.location.pathname === safeHref : false;
+      }
+    });
+  }
+  return el;
 }
 
 // src/router/outlet.ts
@@ -249,17 +287,44 @@ function buildLevels(matched) {
   }));
 }
 function buildInsideOutFactory(matched, levels, startAt, router) {
-  let factory = matched[matched.length - 1].route.component;
+  const ssrCtx = getSSRContext();
+  const wrapForSSR = (route, routeIndex) => {
+    if (!ssrCtx)
+      return route.component;
+    const resolved = ssrCtx.resolvedComponents?.get(route);
+    if (resolved)
+      return resolved;
+    return () => {
+      const result = route.component();
+      if (result instanceof Promise) {
+        if (!ssrCtx.pendingRouteComponents) {
+          ssrCtx.pendingRouteComponents = new Map;
+        }
+        ssrCtx.pendingRouteComponents.set(route, result);
+        for (let j = routeIndex + 1;j < matched.length; j++) {
+          const childRoute = matched[j].route;
+          if (!ssrCtx.pendingRouteComponents.has(childRoute)) {
+            const childResult = childRoute.component();
+            if (childResult instanceof Promise) {
+              ssrCtx.pendingRouteComponents.set(childRoute, childResult);
+            }
+          }
+        }
+      }
+      return result;
+    };
+  };
+  let factory = wrapForSSR(matched[matched.length - 1].route, matched.length - 1);
   for (let i = matched.length - 2;i >= startAt; i--) {
     const level = levels[i];
     const childFactory = factory;
     level.childSignal.value = childFactory;
-    const parentRoute = level.route;
+    const parentComponent = wrapForSSR(level.route, i);
     const cs = level.childSignal;
     factory = () => {
       let result;
       OutletContext.Provider({ childComponent: cs, router }, () => {
-        result = parentRoute.component();
+        result = parentComponent();
       });
       return result;
     };
@@ -285,4 +350,4 @@ function useSearchParams(searchSignal) {
   return searchSignal.value;
 }
 
-export { createLink, RouterContext, useRouter, useParams, OutletContext, Outlet, RouterView, parseSearchParams, useSearchParams };
+export { createLink, Link, OutletContext, Outlet, RouterView, parseSearchParams, useSearchParams };

package/dist/shared/{chunk-1wby7nex.js → chunk-dhehvmj0.js}

@@ -3,10 +3,10 @@ import {
   __element,
   __enterChildren,
   __exitChildren
-} from "./chunk-j6qyxfdc.js";
+} from "./chunk-vndfjfdy.js";
 import {
   getSSRContext
-} from "./chunk-8hsz5y4a.js";
+} from "./chunk-4fwcwxn6.js";
 
 // src/component/children.ts
 var MAX_RESOLVE_DEPTH = 100;
@@ -757,6 +757,143 @@ ${props}
 }`;
 }
 
+// src/css/sanitize.ts
+function sanitizeCssValue(value) {
+  return value.replace(/[;{}<>']/g, "").replace(/url\s*\(/gi, "").replace(/expression\s*\(/gi, "").replace(/@import/gi, "");
+}
+function escapeHtmlAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&#39;");
+}
+
+// src/css/font.ts
+function font(family, options) {
+  return {
+    __brand: "FontDescriptor",
+    family,
+    weight: String(options.weight),
+    style: options.style ?? "normal",
+    display: options.display ?? "swap",
+    src: options.src,
+    fallback: options.fallback ?? [],
+    subsets: options.subsets ?? ["latin"],
+    unicodeRange: options.unicodeRange,
+    adjustFontFallback: options.adjustFontFallback ?? true
+  };
+}
+function toCssWeight(weight) {
+  return sanitizeCssValue(weight).replace("..", " ");
+}
+function buildFontFace(family, src, weight, style, display, unicodeRange) {
+  const safeFamily = sanitizeCssValue(family);
+  const safeSrc = sanitizeCssValue(src);
+  const safeStyle = sanitizeCssValue(style);
+  const safeDisplay = sanitizeCssValue(display);
+  const lines = [
+    "@font-face {",
+    `  font-family: '${safeFamily}';`,
+    `  font-style: ${safeStyle};`,
+    `  font-weight: ${toCssWeight(weight)};`,
+    `  font-display: ${safeDisplay};`,
+    `  src: url(${safeSrc}) format('woff2');`
+  ];
+  if (unicodeRange) {
+    lines.push(`  unicode-range: ${sanitizeCssValue(unicodeRange)};`);
+  }
+  lines.push("}");
+  return lines.join(`
+`);
+}
+var PERCENT_RE = /^\d+\.\d+%$/;
+function sanitizeMetricValue(value) {
+  if (!PERCENT_RE.test(value)) {
+    throw new Error(`Invalid font metric override value: "${value}"`);
+  }
+  return value;
+}
+function buildFallbackFontFace(family, metrics) {
+  const safeFamily = sanitizeCssValue(family);
+  const lines = [
+    "@font-face {",
+    `  font-family: '${safeFamily} Fallback';`,
+    `  src: local('${metrics.fallbackFont}');`,
+    `  ascent-override: ${sanitizeMetricValue(metrics.ascentOverride)};`,
+    `  descent-override: ${sanitizeMetricValue(metrics.descentOverride)};`,
+    `  line-gap-override: ${sanitizeMetricValue(metrics.lineGapOverride)};`,
+    `  size-adjust: ${sanitizeMetricValue(metrics.sizeAdjust)};`,
+    "}"
+  ];
+  return lines.join(`
+`);
+}
+function validateWoff2Src(path) {
+  if (!path.toLowerCase().endsWith(".woff2")) {
+    throw new Error(`Font src "${path}" is not a .woff2 file. Only woff2 format is currently supported.`);
+  }
+}
+function compileFonts(fonts, options) {
+  const fontFaces = [];
+  const cssVars = [];
+  const preloadPaths = [];
+  const fallbackMetrics = options?.fallbackMetrics;
+  for (const [key, descriptor] of Object.entries(fonts)) {
+    if (!/^[a-zA-Z0-9-]+$/.test(key)) {
+      throw new Error(`Font key "${key}" contains invalid CSS identifier characters. Use only [a-zA-Z0-9-].`);
+    }
+    const { family, weight, style, display, src, fallback, unicodeRange } = descriptor;
+    const adjustFontFallback = descriptor.adjustFontFallback ?? true;
+    const metrics = fallbackMetrics?.[key];
+    const shouldGenerateFallback = metrics && src && adjustFontFallback !== false;
+    const safeFamily = sanitizeCssValue(family);
+    const safeFallbacks = fallback.map(sanitizeCssValue);
+    const fallbackFontName = shouldGenerateFallback ? `'${safeFamily} Fallback'` : undefined;
+    const familyParts = [
+      `'${safeFamily}'`,
+      ...fallbackFontName ? [fallbackFontName] : [],
+      ...safeFallbacks
+    ];
+    const familyValue = familyParts.join(", ");
+    cssVars.push(`  --font-${sanitizeCssValue(key)}: ${familyValue};`);
+    if (!src)
+      continue;
+    if (typeof src === "string") {
+      validateWoff2Src(src);
+      fontFaces.push(buildFontFace(family, src, weight, style, display, unicodeRange));
+      preloadPaths.push(src);
+    } else {
+      for (const entry of src) {
+        validateWoff2Src(entry.path);
+        const entryWeight = entry.weight != null ? String(entry.weight) : weight;
+        const entryStyle = entry.style ?? style;
+        fontFaces.push(buildFontFace(family, entry.path, entryWeight, entryStyle, display, unicodeRange));
+      }
+      const first = src[0];
+      if (first) {
+        preloadPaths.push(first.path);
+      }
+    }
+    if (shouldGenerateFallback) {
+      fontFaces.push(buildFallbackFontFace(family, metrics));
+    }
+  }
+  const fontFaceCss = fontFaces.join(`
+
+`);
+  const cssVarLines = cssVars;
+  const cssVarsCss = cssVars.length > 0 ? `:root {
+${cssVars.join(`
+`)}
+}` : "";
+  const preloadTags = preloadPaths.map((p) => `<link rel="preload" href="${escapeHtmlAttr(p)}" as="font" type="font/woff2" crossorigin>`).join(`
+`);
+  const preloadItems = preloadPaths.map((href) => ({
+    href,
+    as: "font",
+    type: "font/woff2",
+    crossorigin: true
+  }));
+  return { fontFaceCss, cssVarsCss, cssVarLines, preloadTags, preloadItems };
+}
+
 // src/css/global-css.ts
 function globalCss(input) {
   const rules = [];
@@ -810,16 +947,14 @@ class InlineStyleError extends Error {
 }
 
 // src/css/theme.ts
-function sanitizeCssValue(value) {
-  return value.replace(/[;{}]/g, "").replace(/url\s*\(/gi, "").replace(/expression\s*\(/gi, "").replace(/@import/gi, "");
-}
 function defineTheme(input) {
   return {
     colors: input.colors,
-    spacing: input.spacing
+    spacing: input.spacing,
+    fonts: input.fonts
   };
 }
-function compileTheme(theme) {
+function compileTheme(theme, options) {
   const rootVars = [];
   const darkVars = [];
   const tokenPaths = [];
@@ -864,7 +999,22 @@ function compileTheme(theme) {
       tokenPaths.push(`spacing.${name}`);
     }
   }
+  let fontFaceCss = "";
+  let preloadTags = "";
+  let preloadItems = [];
+  if (theme.fonts) {
+    const compiled = compileFonts(theme.fonts, {
+      fallbackMetrics: options?.fallbackMetrics
+    });
+    fontFaceCss = compiled.fontFaceCss;
+    preloadTags = compiled.preloadTags;
+    preloadItems = compiled.preloadItems;
+    rootVars.push(...compiled.cssVarLines);
+  }
   const blocks = [];
+  if (fontFaceCss) {
+    blocks.push(fontFaceCss);
+  }
   if (rootVars.length > 0) {
     blocks.push(`:root {
 ${rootVars.join(`
@@ -880,7 +1030,9 @@ ${darkVars.join(`
   return {
     css: blocks.join(`
 `),
-    tokens: tokenPaths
+    tokens: tokenPaths,
+    preloadTags,
+    preloadItems
   };
 }
 
@@ -1017,4 +1169,4 @@ function variants(config) {
   return fn;
 }
 
-export { resolveChildren, children, PROPERTY_MAP, KEYWORD_MAP, DISPLAY_MAP, SPACING_SCALE, RADIUS_SCALE, SHADOW_SCALE, FONT_SIZE_SCALE, FONT_WEIGHT_SCALE, LINE_HEIGHT_SCALE, ALIGNMENT_MAP, SIZE_KEYWORDS, HEIGHT_AXIS_PROPERTIES, COLOR_NAMESPACES, CSS_COLOR_KEYWORDS, CONTENT_MAP, PSEUDO_PREFIXES, PSEUDO_MAP, injectCSS, resetInjectedStyles, getInjectedCSS, css, globalCss, s, defineTheme, compileTheme, ThemeProvider, variants };
+export { resolveChildren, children, PROPERTY_MAP, KEYWORD_MAP, DISPLAY_MAP, SPACING_SCALE, RADIUS_SCALE, SHADOW_SCALE, FONT_SIZE_SCALE, FONT_WEIGHT_SCALE, LINE_HEIGHT_SCALE, ALIGNMENT_MAP, SIZE_KEYWORDS, HEIGHT_AXIS_PROPERTIES, COLOR_NAMESPACES, CSS_COLOR_KEYWORDS, CONTENT_MAP, PSEUDO_PREFIXES, PSEUDO_MAP, injectCSS, resetInjectedStyles, getInjectedCSS, css, font, compileFonts, globalCss, s, defineTheme, compileTheme, ThemeProvider, variants };

package/dist/shared/{chunk-wymw818z.js → chunk-fkbgbf3n.js}

@@ -1,14 +1,17 @@
 import {
   executeLoaders,
   matchRoute
-} from "./chunk-83g4h38e.js";
+} from "./chunk-6wd36w21.js";
 import {
   prefetchNavData
 } from "./chunk-jrtrk5z4.js";
+import {
+  isBrowser
+} from "./chunk-14eqne2a.js";
 import {
   getSSRContext,
   signal
-} from "./chunk-8hsz5y4a.js";
+} from "./chunk-4fwcwxn6.js";
 
 // src/router/navigate.ts
 var DEFAULT_NAV_THRESHOLD_MS = 500;
@@ -59,24 +62,34 @@ function buildSearch(search) {
 function buildNavigationUrl(to, options) {
   return `${interpolatePath(to, options?.params)}${buildSearch(options?.search)}`;
 }
-function createRouter(routes, initialUrl, options) {
+function createRouter(routes, initialUrlOrOptions, maybeOptions) {
+  const initialUrl = typeof initialUrlOrOptions === "string" ? initialUrlOrOptions : undefined;
+  const options = typeof initialUrlOrOptions === "object" ? initialUrlOrOptions : maybeOptions;
   const ssrCtx = getSSRContext();
-  const isSSR = ssrCtx !== undefined;
-  if (isSSR || typeof window === "undefined") {
+  if (!isBrowser()) {
+    let registerRoutesForDiscovery = function(ctx) {
+      if (!ctx.discoveredRoutes) {
+        ctx.discoveredRoutes = collectRoutePatterns(routes);
+      }
+    };
     const ssrUrl = initialUrl ?? ssrCtx?.url ?? "/";
     const fallbackMatch = matchRoute(routes, ssrUrl);
     return {
       current: {
         get value() {
           const ctx = getSSRContext();
-          if (ctx)
+          if (ctx) {
+            registerRoutesForDiscovery(ctx);
             return matchRoute(routes, ctx.url);
+          }
           return fallbackMatch;
         },
         peek() {
           const ctx = getSSRContext();
-          if (ctx)
+          if (ctx) {
+            registerRoutesForDiscovery(ctx);
             return matchRoute(routes, ctx.url);
+          }
           return fallbackMatch;
         },
         notify() {}
@@ -129,8 +142,12 @@ function createRouter(routes, initialUrl, options) {
   const current = {
     get value() {
       const ctx = getSSRContext();
-      if (ctx)
+      if (ctx) {
+        if (!ctx.discoveredRoutes) {
+          ctx.discoveredRoutes = collectRoutePatterns(routes);
+        }
         return matchRoute(routes, ctx.url);
+      }
       return _current.value;
     },
     set value(v) {
@@ -138,8 +155,12 @@ function createRouter(routes, initialUrl, options) {
     },
     peek() {
       const ctx = getSSRContext();
-      if (ctx)
+      if (ctx) {
+        if (!ctx.discoveredRoutes) {
+          ctx.discoveredRoutes = collectRoutePatterns(routes);
+        }
         return matchRoute(routes, ctx.url);
+      }
       return _current.peek();
     },
     notify() {
@@ -298,5 +319,23 @@ function createRouter(routes, initialUrl, options) {
     searchParams
   };
 }
+function collectRoutePatterns(routes, prefix = "") {
+  const patterns = [];
+  for (const route of routes) {
+    const fullPattern = joinPatterns(prefix, route.pattern);
+    patterns.push(fullPattern);
+    if (route.children) {
+      patterns.push(...collectRoutePatterns(route.children, fullPattern));
+    }
+  }
+  return patterns;
+}
+function joinPatterns(parent, child) {
+  if (!parent || parent === "/")
+    return child;
+  if (child === "/")
+    return parent;
+  return `${parent.replace(/\/$/, "")}/${child.replace(/^\//, "")}`;
+}
 
 export { createRouter };

package/dist/shared/{chunk-5dbq8jp9.js → chunk-j09yyh34.js}

@@ -1,7 +1,7 @@
 import {
   computed,
   signal
-} from "./chunk-8hsz5y4a.js";
+} from "./chunk-4fwcwxn6.js";
 
 // src/form/field-state.ts
 function createFieldState(_name, initialValue) {
@@ -31,14 +31,40 @@ function createFieldState(_name, initialValue) {
 function formDataToObject(formData, options) {
   const result = {};
   const coerce = options?.coerce ?? false;
+  const nested = options?.nested ?? false;
   for (const [key, value] of formData.entries()) {
     if (typeof value !== "string") {
       continue;
     }
-    result[key] = coerce ? coerceValue(value) : value;
+    const coerced = coerce ? coerceValue(value) : value;
+    if (nested && key.includes(".")) {
+      setNestedValue(result, key, coerced);
+    } else {
+      result[key] = coerced;
+    }
   }
   return result;
 }
+var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function setNestedValue(obj, dotPath, value) {
+  const segments = dotPath.split(".");
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (DANGEROUS_KEYS.has(segment))
+      return;
+    const nextSegment = segments[i + 1];
+    const isNextArray = /^\d+$/.test(nextSegment);
+    if (!(segment in current)) {
+      current[segment] = isNextArray ? [] : {};
+    }
+    current = current[segment];
+  }
+  const lastSegment = segments[segments.length - 1];
+  if (DANGEROUS_KEYS.has(lastSegment))
+    return;
+  current[lastSegment] = value;
+}
 function coerceValue(value) {
   if (value === "true")
     return true;
@@ -79,8 +105,11 @@ function validate(schema, data) {
 }
 
 // src/form/form.ts
+var FIELD_STATE_SIGNALS = new Set(["error", "dirty", "touched", "value"]);
+var FIELD_STATE_METHODS = new Set(["setValue", "reset"]);
 function form(sdkMethod, options) {
   const fieldCache = new Map;
+  const chainProxyCache = new Map;
   const submitting = signal(false);
   const fieldGeneration = signal(0);
   const dirty = computed(() => {
@@ -99,20 +128,57 @@ function form(sdkMethod, options) {
     }
     return true;
   });
+  function resolveNestedInitial(dotPath) {
+    const initialObj = typeof options?.initial === "function" ? options.initial() : options?.initial;
+    if (!initialObj)
+      return;
+    const segments = dotPath.split(".");
+    let current = initialObj;
+    for (const segment of segments) {
+      if (current == null || typeof current !== "object")
+        return;
+      current = current[segment];
+    }
+    return current;
+  }
   function getOrCreateField(name) {
     let field = fieldCache.get(name);
     if (!field) {
-      const initialObj = typeof options?.initial === "function" ? options.initial() : options?.initial;
-      const initialValue = initialObj?.[name];
+      const initialValue = name.includes(".") ? resolveNestedInitial(name) : (() => {
+        const initialObj = typeof options?.initial === "function" ? options.initial() : options?.initial;
+        return initialObj?.[name];
+      })();
       field = createFieldState(name, initialValue);
       fieldCache.set(name, field);
       fieldGeneration.value++;
     }
     return field;
   }
+  function getOrCreateChainProxy(dotPath) {
+    let proxy = chainProxyCache.get(dotPath);
+    if (proxy)
+      return proxy;
+    proxy = new Proxy(Object.create(null), {
+      get(_target, prop) {
+        if (typeof prop === "string") {
+          if (FIELD_STATE_SIGNALS.has(prop)) {
+            return getOrCreateField(dotPath)[prop];
+          }
+          if (FIELD_STATE_METHODS.has(prop)) {
+            return getOrCreateField(dotPath)[prop];
+          }
+          const childPath = `${dotPath}.${prop}`;
+          return getOrCreateChainProxy(childPath);
+        }
+        return;
+      }
+    });
+    chainProxyCache.set(dotPath, proxy);
+    return proxy;
+  }
   const resolvedSchema = options?.schema ?? sdkMethod.meta?.bodySchema;
   async function submitPipeline(formData) {
-    const data = formDataToObject(formData);
+    const data = formDataToObject(formData, { nested: true });
     if (resolvedSchema) {
       const result2 = validate(resolvedSchema, data);
       if (!result2.success) {
@@ -227,7 +293,7 @@ function form(sdkMethod, options) {
         if (knownProperties.has(prop)) {
           return target[prop];
         }
-        return getOrCreateField(prop);
+        return getOrCreateChainProxy(prop);
       }
       return Reflect.get(target, prop, receiver);
     }

package/dist/shared/chunk-mtsvrj9e.js

@@ -0,0 +1,23 @@
+import {
+  createContext,
+  useContext
+} from "./chunk-4fwcwxn6.js";
+
+// src/router/router-context.ts
+var RouterContext = createContext(undefined, "@vertz/ui::RouterContext");
+function useRouter() {
+  const router = useContext(RouterContext);
+  if (!router) {
+    throw new Error("useRouter() must be called within RouterContext.Provider");
+  }
+  return router;
+}
+function useParams() {
+  const router = useContext(RouterContext);
+  if (!router) {
+    throw new Error("useParams() must be called within RouterContext.Provider");
+  }
+  return router.current?.parsedParams ?? router.current?.params ?? {};
+}
+
+export { RouterContext, useRouter, useParams };

package/dist/shared/chunk-pnv25zep.js

@@ -0,0 +1,7 @@
+// src/dom/events.ts
+function __on(el, event, handler) {
+  el.addEventListener(event, handler);
+  return () => el.removeEventListener(event, handler);
+}
+
+export { __on };

package/dist/shared/{chunk-j6qyxfdc.js → chunk-vndfjfdy.js}

@@ -6,10 +6,10 @@ import {
 import {
   getAdapter,
   isRenderNode
-} from "./chunk-h89w580h.js";
+} from "./chunk-afawz764.js";
 import {
   domEffect
-} from "./chunk-8hsz5y4a.js";
+} from "./chunk-4fwcwxn6.js";
 
 // src/hydrate/hydration-context.ts
 var isHydrating = false;
@@ -371,4 +371,4 @@ function __exitChildren() {
   }
 }
 
-export { startHydration, endHydration, getIsHydrating, claimText, claimComment, __text, __child, __insert, __element, __append, __staticText, __enterChildren, __exitChildren };
+export { startHydration, endHydration, getIsHydrating, claimElement, claimText, claimComment, enterChildren, exitChildren, __text, __child, __insert, __element, __append, __staticText, __enterChildren, __exitChildren };