praxis-kit 4.1.3 → 6.0.0

package/dist/solid/index.js

@@ -445,6 +445,19 @@ function makeResolveTag(defaultTag) {
   };
 }
 
+// ../../lib/primitive/src/rule/rule-brand.ts
+var RULE_BRAND = /* @__PURE__ */ Symbol("praxis-kit/dynamic-rule");
+
+// ../../lib/primitive/src/rule/is-dynamic-rule.ts
+function isDynamicRule(rule) {
+  return isObject(rule, true) && rule[RULE_BRAND] === true;
+}
+
+// ../../lib/primitive/src/rule/resolve-rule.ts
+function resolveRule(rule, context) {
+  return isDynamicRule(rule) ? rule.resolve(context) : rule;
+}
+
 // ../../lib/primitive/src/utils/assert-never.ts
 function assertNever(value) {
   throw new Error(`Unexpected value: ${String(value)}`);
@@ -1856,32 +1869,68 @@ var RuleValidator = class _RuleValidator extends InvariantBase {
 };
 
 // ../../lib/contract/src/children/children-evaluator.ts
+var isTextLike = (child) => isString(child) || isNumber(child);
+function checkPositionCardinalityInvariant(rules, context) {
+  iterate.forEach(rules, (rule) => {
+    const { name, position, cardinality } = rule;
+    if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
+      throw new RangeError(
+        `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
+      );
+    }
+  });
+}
 var ChildrenEvaluator = class extends InvariantBase {
   #context;
-  #rules;
-  #ruleNames;
+  /** Rules with a static cardinality — normalized once, reused on every evaluate() call. */
+  #staticRules;
+  /** Rules whose cardinality is `dynamic(...)` — re-resolved against a ChildRuleContext per call. */
+  #dynamicRuleInputs;
   #matcher;
   #ruleValidator;
-  constructor(rules, diagnostics, context = "Component") {
+  #exclusiveChildren;
+  #allowText;
+  constructor(rules, diagnostics, context = "Component", options = {}) {
     super(diagnostics);
     this.#context = context;
-    this.#rules = rules.map((r) => normalizeChildRule(r));
-    this.#ruleNames = this.#rules.map((r) => r.name);
-    iterate.forEach(this.#rules, (rule) => {
-      const { name, position, cardinality } = rule;
-      if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
-        throw new RangeError(
-          `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
-        );
-      }
+    this.#exclusiveChildren = options.exclusiveChildren ?? false;
+    this.#allowText = options.allowText ?? true;
+    const staticRuleInputs = [];
+    const dynamicRuleInputs = [];
+    iterate.forEach(rules, (rule) => {
+      if (isDynamicRule(rule.cardinality)) dynamicRuleInputs.push(rule);
+      else staticRuleInputs.push(rule);
     });
-    this.#matcher = new RuleMatcher(this.#rules);
+    this.#dynamicRuleInputs = dynamicRuleInputs;
+    this.#staticRules = staticRuleInputs.map(
+      (r) => normalizeChildRule(r)
+    );
     this.#ruleValidator = new RuleValidator(context, diagnostics);
+    if (this.#dynamicRuleInputs.length === 0) {
+      checkPositionCardinalityInvariant(this.#staticRules, context);
+      this.#matcher = new RuleMatcher(this.#staticRules);
+    } else {
+      this.#matcher = void 0;
+    }
   }
-  evaluate(children) {
+  /**
+   * @param context Required when any rule has a `dynamic(...)` cardinality —
+   *   supplies the resolved tag/props those rules are evaluated against.
+   */
+  evaluate(children, context) {
     if (!this.active) return;
-    const { matrix, unexpectedIndices, ambiguousIndices } = this.#matcher.match(children);
-    this.#ruleValidator.validate(this.#rules, matrix, children.length);
+    const { rules, matcher } = this.#resolveRules(context);
+    const {
+      matrix,
+      unexpectedIndices: rawUnexpectedIndices,
+      ambiguousIndices
+    } = matcher.match(children);
+    this.#ruleValidator.validate(rules, matrix, children.length);
+    const unexpectedIndices = new Set(
+      [...rawUnexpectedIndices].filter(
+        (ci) => isTextLike(children[ci]) ? this.#allowText === false : this.#exclusiveChildren
+      )
+    );
     if (unexpectedIndices.size === 0 && ambiguousIndices.size === 0) return;
     const violating = [...unexpectedIndices, ...ambiguousIndices].sort((a, b) => a - b);
     iterate.forEach(violating, (ci) => {
@@ -1890,11 +1939,28 @@ var ChildrenEvaluator = class extends InvariantBase {
         this.violate(ContractDiagnostics.unexpectedChild(typeName, ci, this.#context));
       } else {
         const matches = matrix.childToRules.forward.get(ci);
-        const names = [...matches].map((ri) => this.#ruleNames[ri] ?? `#${ri}`);
+        const names = [...matches].map((ri) => rules[ri]?.name ?? `#${ri}`);
         this.violate(ContractDiagnostics.ambiguousChild(typeName, ci, names, this.#context));
       }
     });
   }
+  #resolveRules(context) {
+    if (this.#dynamicRuleInputs.length === 0) {
+      return { rules: this.#staticRules, matcher: this.#matcher };
+    }
+    if (context === void 0) {
+      throw new RangeError(
+        `ChildrenEvaluator [${this.#context}]: rule(s) have a dynamic(...) cardinality \u2014 evaluate() requires a context argument to resolve them.`
+      );
+    }
+    const resolvedDynamicRules = this.#dynamicRuleInputs.map((r) => {
+      const cardinality = resolveRule(r.cardinality, context);
+      return normalizeChildRule({ ...r, cardinality });
+    });
+    checkPositionCardinalityInvariant(resolvedDynamicRules, this.#context);
+    const rules = [...this.#staticRules, ...resolvedDynamicRules];
+    return { rules, matcher: new RuleMatcher(rules) };
+  }
 };
 
 // ../../lib/contract/src/props/get-disabled-props.ts
@@ -2003,8 +2069,11 @@ function metadata(name = "metadata") {
 function firstOptional(name, tag) {
   return { name, match: isTag(tag), cardinality: { max: 1 }, position: "first" };
 }
-function contract(children) {
-  return { diagnostics: warnDiagnostics, children };
+function contract(children, options) {
+  return { diagnostics: warnDiagnostics, children, ...options };
+}
+function closedContract(children) {
+  return contract(children, { exclusiveChildren: true });
 }
 function ariaContract(aria) {
   return { diagnostics: warnDiagnostics, aria };
@@ -2030,8 +2099,10 @@ var VOID_TAGS = [
 ];
 var TEXT_ONLY_TAGS = ["option", "script", "style", "textarea", "title"];
 var LANDMARK_TAGS = ["article", "aside", "footer", "header", "main", "nav"];
-var listContract = contract([{ name: "list-item", match: isTag("li", ...METADATA_TAGS) }]);
-var tableContract = contract([
+var listContract = closedContract([
+  { name: "list-item", match: isTag("li", ...METADATA_TAGS) }
+]);
+var tableContract = closedContract([
   firstOptional("caption", "caption"),
   { name: "colgroup", match: isTag("colgroup") },
   { name: "thead", match: isTag("thead"), cardinality: { max: 1 } },
@@ -2039,29 +2110,31 @@ var tableContract = contract([
   { name: "tfoot", match: isTag("tfoot"), cardinality: { max: 1 } },
   { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
 ]);
-var tableBodyContract = contract([
+var tableBodyContract = closedContract([
   { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
 ]);
-var tableRowContract = contract([
+var tableRowContract = closedContract([
   { name: "table-cell", match: isTag("td", "th", ...METADATA_TAGS) }
 ]);
-var colgroupContract = contract([{ name: "column", match: isTag("col", "template") }]);
-var dlContract = contract([
+var colgroupContract = closedContract([
+  { name: "column", match: isTag("col", "template") }
+]);
+var dlContract = closedContract([
   { name: "term", match: isTag("dt") },
   { name: "description", match: isTag("dd") },
   { name: "group", match: isTag("div") },
   metadata()
 ]);
-var selectContract = contract([
+var selectContract = closedContract([
   { name: "option", match: isTag("option", "optgroup", "hr", ...METADATA_TAGS) }
 ]);
-var optgroupContract = contract([
+var optgroupContract = closedContract([
   { name: "option", match: isTag("option", ...METADATA_TAGS) }
 ]);
-var datalistContract = contract([
+var datalistContract = closedContract([
   { name: "option", match: isTag("option", ...METADATA_TAGS) }
 ]);
-var pictureContract = contract([
+var pictureContract = closedContract([
   { name: "source", match: isTag("source", ...METADATA_TAGS) },
   { name: "image", match: isTag("img"), cardinality: { min: 1, max: 1 }, position: "last" }
 ]);
@@ -2077,23 +2150,18 @@ var mediaContract = contract([
   metadata(),
   { name: "content", match: isOpenContent("source", "track", ...METADATA_TAGS) }
 ]);
-var headContract = contract([
+var headContract = closedContract([
   {
     name: "metadata",
     match: isTag("base", "link", "meta", "noscript", "script", "style", "template", "title")
   }
 ]);
-var htmlContract = contract([
+var htmlContract = closedContract([
   { name: "head", match: isTag("head"), cardinality: { min: 1, max: 1 }, position: "first" },
   { name: "body", match: isTag("body"), cardinality: { min: 1, max: 1 } }
 ]);
-var voidContract = contract([]);
-var textOnlyContract = contract([
-  {
-    name: "text",
-    match: (child) => isString(child) || isNumber(child)
-  }
-]);
+var voidContract = contract([], { exclusiveChildren: true, allowText: false });
+var textOnlyContract = contract([], { exclusiveChildren: true });
 var landmarkContract = ariaContract([landmarkRoleRule, landmarkNameAdvisory]);
 var dialogContract = ariaContract([requireAccessibleName]);
 var menuContract = ariaContract([requireAccessibleName]);
@@ -2138,9 +2206,15 @@ var htmlContracts = {
 var htmlDiagnostics = warnDiagnostics2;
 function buildEvaluatorMap() {
   const map2 = /* @__PURE__ */ new Map();
-  iterate.forEachEntry(htmlContracts, (tag, { children }) => {
-    if (children?.length) {
-      map2.set(tag, new ChildrenEvaluator(children, htmlDiagnostics, `<${tag}>`));
+  iterate.forEachEntry(htmlContracts, (tag, { children, exclusiveChildren, allowText }) => {
+    if (children?.length || exclusiveChildren || allowText === false) {
+      map2.set(
+        tag,
+        new ChildrenEvaluator(children ?? [], htmlDiagnostics, `<${tag}>`, {
+          exclusiveChildren,
+          allowText
+        })
+      );
     }
   });
   return map2;
@@ -2351,7 +2425,7 @@ function definePipeline(factory) {
 }
 
 // ../core/src/options/resolve-factory-options.ts
-import { silentDiagnostics } from "../_shared/diagnostics.js";
+import { resolveDiagnostics, silentDiagnostics } from "../_shared/diagnostics.js";
 var EMPTY_VARIANT_KEYS = /* @__PURE__ */ new Set();
 function composeNormalizers(normalizers, fn) {
   if (!normalizers?.length) return fn;
@@ -2372,7 +2446,7 @@ function resolveFactoryOptions(options = {}) {
   const variantKeys = styling?.variants === void 0 ? EMPTY_VARIANT_KEYS : new Set(Object.keys(styling.variants));
   return Object.freeze({
     defaultTag: options.tag ?? "div",
-    diagnostics: enforcement?.diagnostics ?? silentDiagnostics,
+    diagnostics: resolveDiagnostics(enforcement?.diagnostics, silentDiagnostics),
     variantKeys,
     ...whenDefined("displayName", options.name),
     ...whenDefined("defaultProps", options.defaults),
@@ -2385,6 +2459,8 @@ function resolveFactoryOptions(options = {}) {
     ...whenDefined("normalizeFn", composedNormalizeFn),
     ...whenDefined("ariaRules", enforcement?.aria),
     ...whenDefined("childRules", enforcement?.children),
+    ...whenDefined("exclusiveChildren", enforcement?.exclusiveChildren),
+    ...whenDefined("allowText", enforcement?.allowText),
     ...whenDefined("allowedAs", enforcement?.allowedAs),
     ...whenDefined("precomputedClasses", styling?.precomputedClasses)
   });
@@ -2569,16 +2645,22 @@ function buildCoreRuntime(normalized) {
 }
 
 // ../../lib/adapter-utils/src/runtime/build-engines.ts
-function buildEngines(diagnostics, childRules, context) {
-  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, diagnostics, context) } : {};
+function buildEngines(diagnostics, childRules, context, childrenOptions) {
+  const { exclusiveChildren, allowText } = childrenOptions ?? {};
+  return childRules?.length || exclusiveChildren || allowText === false ? {
+    childrenEvaluator: new ChildrenEvaluator(childRules ?? [], diagnostics, context, {
+      exclusiveChildren,
+      allowText
+    })
+  } : {};
 }
 
 // ../../lib/adapter-utils/src/runtime/resolve-adapter-common-options.ts
-import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics3 } from "../_shared/diagnostics.js";
+import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics3, resolveDiagnostics as resolveDiagnostics2 } from "../_shared/diagnostics.js";
 function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics2) {
   return {
     name: options.name ?? defaultName,
-    diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
+    diagnostics: resolveDiagnostics2(options.enforcement?.diagnostics, defaultDiagnostics)
   };
 }
 
@@ -2633,7 +2715,11 @@ function buildRuntime(options) {
   const { childrenEvaluator } = buildEngines(
     normalized.diagnostics,
     normalized.enforcement?.children,
-    normalized.name
+    normalized.name,
+    {
+      exclusiveChildren: normalized.enforcement?.exclusiveChildren,
+      allowText: normalized.enforcement?.allowText
+    }
   );
   const filterProps = composeFilter(ownedKeys, normalized.filterProps);
   const slotValidator = new SlotValidator(normalized.name, normalized.diagnostics);
@@ -2646,9 +2732,10 @@ function buildRuntime(options) {
 }
 
 // ../../adapters/solid/src/render.tsx
+import { createComponent as _$createComponent } from "solid-js/web";
+import { mergeProps as _$mergeProps } from "solid-js/web";
 import { createEffect, createMemo, splitProps } from "solid-js";
 import { Dynamic } from "solid-js/web";
-import { jsx } from "solid-js/jsx-runtime";
 var SPLIT_KEYS = ["as", "asChild", "children", "class", "recipe", "ref"];
 function toChildArray(children) {
   if (children === void 0 || children === null) return [];
@@ -2656,22 +2743,38 @@ function toChildArray(children) {
   return [children];
 }
 function buildElementProps(props, classStr, ref, children) {
-  const { role, ...rest } = props;
+  const {
+    role,
+    ...rest
+  } = props;
   return {
     ...rest,
     class: classStr,
-    ...ref !== void 0 && { ref },
-    ...children !== void 0 && { children },
-    ...isKnownAriaRole(role) && { role }
+    ...ref !== void 0 && {
+      ref
+    },
+    ...children !== void 0 && {
+      children
+    },
+    ...isKnownAriaRole(role) && {
+      role
+    }
   };
 }
 function buildSlotProps(props, classStr, ref) {
-  const { role, ...rest } = props;
+  const {
+    role,
+    ...rest
+  } = props;
   return {
     ...rest,
     class: classStr,
-    ...ref !== void 0 && { ref },
-    ...isKnownAriaRole(role) && { role }
+    ...ref !== void 0 && {
+      ref
+    },
+    ...isKnownAriaRole(role) && {
+      role
+    }
   };
 }
 function resolveTag2(runtime, as) {
@@ -2688,9 +2791,7 @@ function tryRenderAsChild(known, filteredProps, resolvedClass, slotValidator) {
   }
   if (!slotValidator.assertRenderFn(known.children)) return null;
   const renderFn = known.children;
-  return createMemo(
-    () => renderFn(buildSlotProps(filteredProps(), resolvedClass(), known.ref))
-  );
+  return createMemo(() => renderFn(buildSlotProps(filteredProps(), resolvedClass(), known.ref)));
 }
 function render({
   runtime,
@@ -2706,32 +2807,27 @@ function render({
   const normalizedProps = createMemo(() => {
     const base = runtime.options.normalizeFn ? runtime.options.normalizeFn(mergedProps()) : mergedProps();
     const htmlNormalizers = runtime.options.htmlPropNormalizersFn?.(tag());
-    return htmlNormalizers?.length ? htmlNormalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), base) : base;
+    return htmlNormalizers?.length ? htmlNormalizers.reduce((acc, fn) => ({
+      ...acc,
+      ...fn(acc)
+    }), base) : base;
   });
-  const resolvedClass = createMemo(
-    () => runtime.resolveClasses(
-      tag(),
-      normalizedProps(),
-      known.class,
-      known.recipe
-    )
-  );
-  const filteredProps = createMemo(
-    () => applyFilter(normalizedProps(), filterProps, runtime.options.variantKeys)
-  );
-  const { allowedAs } = runtime.options;
+  const resolvedClass = createMemo(() => runtime.resolveClasses(tag(), normalizedProps(), known.class, known.recipe));
+  const filteredProps = createMemo(() => applyFilter(normalizedProps(), filterProps, runtime.options.variantKeys));
+  const {
+    allowedAs
+  } = runtime.options;
   if (allowedAs !== void 0) {
-    createEffect(
-      () => enforceAllowedAs(tag(), allowedAs, runtime.options.diagnostics, runtime.options.displayName)
-    );
+    createEffect(() => enforceAllowedAs(tag(), allowedAs, runtime.options.diagnostics, runtime.options.displayName));
   }
   if (process.env.NODE_ENV !== "production" && childrenEvaluator) {
-    createEffect(() => childrenEvaluator.evaluate(toChildArray(known.children)));
+    createEffect(() => childrenEvaluator.evaluate(toChildArray(known.children), {
+      tag: tag(),
+      props: normalizedProps()
+    }));
   }
   if (process.env.NODE_ENV !== "production") {
-    createEffect(
-      () => runtime.options.htmlChildrenEvaluatorFn?.(tag())?.evaluate(toChildArray(known.children))
-    );
+    createEffect(() => runtime.options.htmlChildrenEvaluatorFn?.(tag())?.evaluate(toChildArray(known.children)));
   }
   const slotResult = tryRenderAsChild(known, filteredProps, resolvedClass, slotValidator);
   if (slotResult !== null) return slotResult;
@@ -2739,7 +2835,11 @@ function render({
     const ep = buildElementProps(filteredProps(), resolvedClass(), known.ref, known.children);
     return resolveDomProps(tag(), ep, runtime);
   });
-  return /* @__PURE__ */ jsx(Dynamic, { component: tag(), ...domProps() });
+  return _$createComponent(Dynamic, _$mergeProps({
+    get component() {
+      return tag();
+    }
+  }, () => domProps()));
 }
 
 // ../../adapters/solid/src/create-contract-component.ts

package/dist/svelte/Polymorphic.svelte

@@ -0,0 +1,146 @@
+<script module lang="ts">
+  declare const process: { env: { NODE_ENV: string } }
+</script>
+
+<script lang="ts">
+  import { enforceAllowedAs, isKnownAriaRole } from '@praxis-kit/core'
+  import type { ElementType, IntrinsicProps } from '@praxis-kit/core'
+  import { isObject, isString } from '@praxis-kit/primitive'
+  import { applyFilter } from '@praxis-kit/adapter-utils'
+  import type { Snippet } from 'svelte'
+  import type {
+    PolymorphicComponentProps,
+    ResolvedAttributes,
+    StyleObject,
+    UnknownProps,
+  } from './types'
+
+  let {
+    bundle,
+    as: asProp,
+    asChild,
+    class: cls,
+    recipe,
+    children,
+    ...rest
+  }: PolymorphicComponentProps = $props()
+  let hostEl: Element | undefined = $state()
+
+  // Svelte 5 event delegation requires lowercase handler names (onclick, onfocus…).
+  // Normalize React-style camelCase handlers so spreads on <svelte:element> work.
+  const EVENT_RE = /^on[A-Z]/
+  function normalizeEventKeys(props: UnknownProps): UnknownProps {
+    const out: ResolvedAttributes = {}
+    for (const k in props) {
+      out[EVENT_RE.test(k) ? k.toLowerCase() : k] = (props as ResolvedAttributes)[k]
+    }
+    return out as UnknownProps
+  }
+
+  function serializeStyle(style: StyleObject): string {
+    let result = ''
+    for (const key in style) {
+      const value = style[key]
+      if (value == null) continue
+      if (result) result += ';'
+      result += `${key.replace(/([A-Z])/g, '-$1').toLowerCase()}:${value}`
+    }
+    return result
+  }
+
+  function buildDomProps(
+    props: UnknownProps,
+    classStr: string,
+    tag: ElementType,
+  ): ResolvedAttributes {
+    const { role, style, ...r } = normalizeEventKeys(props)
+    const styleStr = isObject(style, true)
+      ? serializeStyle(style as StyleObject)
+      : (style as string | undefined)
+    const ep: IntrinsicProps = {
+      ...(r as IntrinsicProps),
+      class: classStr,
+      ...(styleStr !== undefined && { style: styleStr }),
+    }
+    if (isKnownAriaRole(role)) ep.role = role
+    if (!isString(tag)) return ep as ResolvedAttributes
+    return bundle.runtime.resolveAria(tag, ep).props as ResolvedAttributes
+  }
+
+  function buildSlotProps(props: UnknownProps, classStr: string): UnknownProps {
+    const { role, ...r } = props
+    return {
+      ...r,
+      class: classStr,
+      ...(isKnownAriaRole(role) && { role }),
+    }
+  }
+
+  const tag = $derived(bundle.runtime.resolveTag(asProp as ElementType | undefined))
+  const mergedProps = $derived(bundle.runtime.resolveProps(rest as UnknownProps))
+  const normalizedProps = $derived.by(() => {
+    const { runtime: { options } } = bundle
+    // Folded into this derived (rather than a standalone one) so it's guaranteed to run on
+    // both SSR and DOM — $derived is lazy in Svelte 5 and only evaluates when read; this one
+    // is read downstream by resolvedClass/filteredProps/domProps, which the template renders.
+    if (options.allowedAs !== undefined) {
+      enforceAllowedAs(
+        tag,
+        options.allowedAs,
+        options.diagnostics,
+        options.displayName,
+      )
+    }
+    const base =
+      typeof options.normalizeFn === 'function' ? options.normalizeFn(mergedProps) : mergedProps
+
+    const htmlNormalizers = options.htmlPropNormalizersFn?.(tag)
+
+    if (!htmlNormalizers?.length) {
+      return base
+    }
+
+    return htmlNormalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), base)
+  })
+  const resolvedClass = $derived(
+    bundle.runtime.resolveClasses(tag, normalizedProps, cls as string | undefined, recipe),
+  )
+  const filteredProps = $derived(
+    applyFilter(normalizedProps, bundle.filterProps, bundle.runtime.options.variantKeys),
+  )
+  const domProps = $derived(buildDomProps(filteredProps, resolvedClass, tag))
+
+  // Resolves whether to render as child slot; also enforces as+asChild mutual exclusion.
+  const useAsChild = $derived.by(() => {
+    if (!asChild) return false
+    if (asProp !== undefined) {
+      bundle.slotValidator.assertExclusive()
+      return false
+    }
+    return true
+  })
+
+  // DOM-only (like Lit skipping htmlChildrenEvaluatorFn for its SSR renderToString). Merely
+  // *registering* $effect during svelte/server's render() throws ("effect_orphan") — it's not
+  // enough to no-op inside the callback, the rune call itself must never happen during SSR.
+  // Reads real child nodes off the mounted host, same approach as Lit's Array.from(this.childNodes).
+  // Not reachable in the asChild branch — no host element there.
+  if (typeof document !== 'undefined') {
+    $effect(() => {
+      if (process.env.NODE_ENV === 'production' || !hostEl) return
+      const childArray = Array.from(hostEl.childNodes)
+      bundle.childrenEvaluator?.evaluate(childArray, { tag, props: normalizedProps })
+      bundle.runtime.options.htmlChildrenEvaluatorFn?.(tag)?.evaluate(childArray)
+    })
+  }
+</script>
+
+{#if useAsChild}
+  {#if children}
+    {@render (children as Snippet<[UnknownProps]>)(buildSlotProps(filteredProps, resolvedClass))}
+  {/if}
+{:else}
+  <svelte:element this={tag as string} bind:this={hostEl} {...domProps}>
+    {@render (children as Snippet | undefined)?.()}
+  </svelte:element>
+{/if}