@barefootjs/client 0.1.0

package/dist/runtime/standalone.js

@@ -0,0 +1,2278 @@
+// src/reactive.ts
+var Owner = null;
+var Listener = null;
+var MAX_EFFECT_RUNS = 100;
+var BatchDepth = 0;
+var PendingEffects = new Set;
+function createSignal(initialValue) {
+  let value = initialValue;
+  const subscribers = new Set;
+  const get = () => {
+    if (Listener) {
+      subscribers.add(Listener);
+      Listener.dependencies.add(subscribers);
+    }
+    return value;
+  };
+  const set = (valueOrFn) => {
+    const newValue = typeof valueOrFn === "function" ? valueOrFn(value) : valueOrFn;
+    if (Object.is(value, newValue)) {
+      return;
+    }
+    value = newValue;
+    if (BatchDepth > 0) {
+      for (const effect of subscribers) {
+        PendingEffects.add(effect);
+      }
+    } else {
+      const effectsToRun = [...subscribers];
+      for (const effect of effectsToRun) {
+        runEffect(effect);
+      }
+    }
+  };
+  return [get, set];
+}
+function createEffect(fn) {
+  const effect = {
+    fn,
+    cleanup: null,
+    dependencies: new Set,
+    owner: Owner,
+    children: [],
+    disposed: false,
+    runCount: 0
+  };
+  if (Owner)
+    Owner.children.push(effect);
+  runEffect(effect);
+}
+function runEffect(effect) {
+  if (effect.disposed)
+    return;
+  effect.runCount++;
+  if (effect.runCount > MAX_EFFECT_RUNS) {
+    effect.runCount = 0;
+    throw new Error(`Circular dependency detected: effect re-entered itself ${MAX_EFFECT_RUNS} times.`);
+  }
+  if (effect.cleanup) {
+    effect.cleanup();
+    effect.cleanup = null;
+  }
+  for (const dep of effect.dependencies) {
+    dep.delete(effect);
+  }
+  effect.dependencies.clear();
+  const prevOwner = Owner;
+  const prevListener = Listener;
+  Owner = effect;
+  Listener = effect;
+  try {
+    const result = effect.fn();
+    if (typeof result === "function") {
+      effect.cleanup = result;
+    }
+  } finally {
+    Owner = prevOwner;
+    Listener = prevListener;
+    effect.runCount--;
+  }
+}
+function disposeSubtree(effect) {
+  if (effect.disposed)
+    return;
+  effect.disposed = true;
+  for (const child of effect.children) {
+    disposeSubtree(child);
+  }
+  effect.children.length = 0;
+  if (effect.cleanup) {
+    effect.cleanup();
+    effect.cleanup = null;
+  }
+  for (const dep of effect.dependencies) {
+    dep.delete(effect);
+  }
+  effect.dependencies.clear();
+  effect.owner = null;
+}
+function disposeEffect(effect) {
+  if (effect.disposed)
+    return;
+  if (effect.owner) {
+    const idx = effect.owner.children.indexOf(effect);
+    if (idx >= 0)
+      effect.owner.children.splice(idx, 1);
+  }
+  disposeSubtree(effect);
+}
+function createRoot(fn) {
+  const root = {
+    fn: () => {},
+    cleanup: null,
+    dependencies: new Set,
+    owner: Owner,
+    children: [],
+    disposed: false,
+    runCount: 0
+  };
+  if (Owner)
+    Owner.children.push(root);
+  const prevOwner = Owner;
+  const prevListener = Listener;
+  Owner = root;
+  Listener = null;
+  try {
+    return fn(() => disposeEffect(root));
+  } finally {
+    Owner = prevOwner;
+    Listener = prevListener;
+  }
+}
+function createDisposableEffect(fn) {
+  let disposed = false;
+  const effect = {
+    fn: () => {
+      if (disposed)
+        return;
+      return fn();
+    },
+    cleanup: null,
+    dependencies: new Set,
+    owner: Owner,
+    children: [],
+    disposed: false,
+    runCount: 0
+  };
+  if (Owner)
+    Owner.children.push(effect);
+  runEffect(effect);
+  return () => {
+    disposeEffect(effect);
+  };
+}
+function onCleanup(fn) {
+  if (Owner) {
+    const effect = Owner;
+    const prevCleanup = effect.cleanup;
+    effect.cleanup = () => {
+      if (prevCleanup)
+        prevCleanup();
+      fn();
+    };
+  }
+}
+function untrack(fn) {
+  const prevListener = Listener;
+  Listener = null;
+  try {
+    return fn();
+  } finally {
+    Listener = prevListener;
+  }
+}
+function batch(fn) {
+  BatchDepth++;
+  try {
+    return fn();
+  } finally {
+    BatchDepth--;
+    if (BatchDepth === 0) {
+      flushEffects();
+    }
+  }
+}
+function flushEffects() {
+  while (PendingEffects.size > 0) {
+    const effects = [...PendingEffects];
+    PendingEffects.clear();
+    for (const effect of effects) {
+      runEffect(effect);
+    }
+  }
+}
+function onMount(fn) {
+  createEffect(() => untrack(fn));
+}
+function createMemo(fn) {
+  const [value, setValue] = createSignal(undefined);
+  createEffect(() => {
+    const result = fn();
+    setValue(() => result);
+  });
+  return value;
+}
+// src/split-props.ts
+function splitProps(props, keys) {
+  const keySet = new Set(keys);
+  const local = new Proxy({}, {
+    get(_, key) {
+      if (keySet.has(key)) {
+        return props[key];
+      }
+      return;
+    },
+    has(_, key) {
+      return keySet.has(key);
+    },
+    ownKeys() {
+      return [...keySet];
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (keySet.has(key)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          get: () => props[key]
+        };
+      }
+      return;
+    }
+  });
+  const rest = new Proxy({}, {
+    get(_, key) {
+      if (!keySet.has(key)) {
+        return props[key];
+      }
+      return;
+    },
+    has(_, key) {
+      return key in props && !keySet.has(key);
+    },
+    ownKeys() {
+      return Object.keys(props).filter((k) => !keySet.has(k));
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (key in props && !keySet.has(key)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          get: () => props[key]
+        };
+      }
+      return;
+    }
+  });
+  return [local, rest];
+}
+// src/slot.ts
+function __slot(thunk) {
+  return {
+    __isSlot: true,
+    toString() {
+      const result = thunk();
+      return result == null ? "" : String(result);
+    }
+  };
+}
+// src/forward-props.ts
+function forwardProps(source, overrides, excludeKeys) {
+  const result = {};
+  const exclude = new Set(excludeKeys);
+  const descs = Object.getOwnPropertyDescriptors(overrides);
+  for (const key of Object.keys(descs)) {
+    Object.defineProperty(result, key, { ...descs[key], enumerable: true, configurable: true });
+  }
+  for (const key of Object.keys(source)) {
+    if (exclude.has(key) || key in result)
+      continue;
+    const k = key;
+    Object.defineProperty(result, k, {
+      get: () => source[k],
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return result;
+}
+// src/unwrap.ts
+function unwrap(prop) {
+  return typeof prop === "function" ? prop() : prop;
+}
+// ../shared/src/markers.ts
+var BF_SCOPE = "bf-s";
+var BF_SLOT = "bf";
+var BF_HOST = "bf-h";
+var BF_AT = "bf-m";
+var BF_PROPS = "bf-p";
+var BF_COND = "bf-c";
+var BF_PORTAL_OWNER = "bf-po";
+var BF_PORTAL_ID = "bf-pi";
+var BF_PORTAL_PLACEHOLDER = "bf-pp";
+var BF_PARENT_OWNED_PREFIX = "^";
+var BF_SCOPE_COMMENT_PREFIX = "bf-scope:";
+var BF_LOOP_START = "bf-loop";
+var BF_LOOP_END = "bf-/loop";
+var BF_LOOP_ITEM = "bf-loop-i";
+function loopStartMarker(markerId) {
+  return `${BF_LOOP_START}:${markerId}`;
+}
+function loopEndMarker(markerId) {
+  return `${BF_LOOP_END}:${markerId}`;
+}
+var BF_KEY = "data-key";
+var BF_ASYNC = "bf-async";
+var BF_ASYNC_RESOLVE = "bf-async-resolve";
+var BF_PARENT_SCOPE_PLACEHOLDER = "__BF_PARENT_SCOPE__";
+// src/context.ts
+function createContext(defaultValue) {
+  return {
+    id: Symbol(),
+    defaultValue,
+    Provider: () => {
+      throw new Error("Context.Provider should be compiled away");
+    }
+  };
+}
+
+// src/runtime/context.ts
+var contextStore = new Map;
+var CONTEXT_KEY = "__bfCtx";
+var currentScope = null;
+function setCurrentScope(scope) {
+  const prev = currentScope;
+  currentScope = scope;
+  return prev;
+}
+function useContext(context) {
+  if (currentScope) {
+    let el = currentScope;
+    while (el) {
+      const ctxMap = el[CONTEXT_KEY];
+      if (ctxMap?.has(context.id)) {
+        return ctxMap.get(context.id);
+      }
+      const portalOwnerId = el.getAttribute(BF_PORTAL_OWNER);
+      if (portalOwnerId) {
+        const ownerEl = document.querySelector(`[${BF_SCOPE}="${portalOwnerId}"]`);
+        if (ownerEl && ownerEl !== el) {
+          el = ownerEl;
+          continue;
+        }
+      }
+      el = el.parentElement;
+    }
+  }
+  if (contextStore.has(context.id)) {
+    return contextStore.get(context.id);
+  }
+  return context.defaultValue;
+}
+function provideContext(context, value) {
+  if (currentScope) {
+    let ctxMap = currentScope[CONTEXT_KEY];
+    if (!ctxMap) {
+      ctxMap = new Map;
+      currentScope[CONTEXT_KEY] = ctxMap;
+    }
+    ctxMap.set(context.id, value);
+    const childScopes = currentScope.querySelectorAll(`[${BF_SCOPE}]`);
+    for (const child of childScopes) {
+      let childCtxMap = child[CONTEXT_KEY];
+      if (!childCtxMap) {
+        childCtxMap = new Map;
+        child[CONTEXT_KEY] = childCtxMap;
+      }
+      if (!childCtxMap.has(context.id)) {
+        childCtxMap.set(context.id, value);
+      }
+    }
+  }
+  contextStore.set(context.id, value);
+}
+// src/runtime/template.ts
+var templateRegistry = new Map;
+function registerTemplate(name, templateFn) {
+  templateRegistry.set(name, templateFn);
+}
+function getTemplate(name) {
+  return templateRegistry.get(name);
+}
+function hasTemplate(name) {
+  return templateRegistry.has(name);
+}
+
+// src/runtime/hydration-state.ts
+var hydratedScopes = new WeakSet;
+
+// src/runtime/scope.ts
+var commentScopeRegistry = new WeakMap;
+function getPortalScopeId(element) {
+  const info = commentScopeRegistry.get(element);
+  return info?.scopeId ?? null;
+}
+function getCommentScopeBoundary(commentNode) {
+  let node = commentNode.nextSibling;
+  while (node) {
+    if (node.nodeType === Node.COMMENT_NODE && node.nodeValue?.startsWith(BF_SCOPE_COMMENT_PREFIX)) {
+      return node;
+    }
+    node = node.nextSibling;
+  }
+  return null;
+}
+
+// src/runtime/query.ts
+var cssEscape = typeof CSS !== "undefined" && CSS.escape ? (s) => CSS.escape(s) : (s) => s.replace(/"/g, "\\\"");
+function getScopeId(el) {
+  return el?.getAttribute(BF_SCOPE) ?? null;
+}
+var initializedComments = new WeakSet;
+function parseCommentScopeId(value, prefix) {
+  if (!value.startsWith(prefix))
+    return null;
+  let id = value.slice(prefix.length);
+  const pipeIdx = id.indexOf("|");
+  if (pipeIdx >= 0)
+    id = id.slice(0, pipeIdx);
+  return id;
+}
+function nextElementSibling(node) {
+  let sibling = node.nextSibling;
+  while (sibling) {
+    if (sibling.nodeType === Node.ELEMENT_NODE)
+      return sibling;
+    sibling = sibling.nextSibling;
+  }
+  return null;
+}
+function findScope(name, idx, parent, comment) {
+  const parentEl = parent;
+  if (parentEl) {
+    const commentInfo = commentScopeRegistry.get(parentEl);
+    if (commentInfo && commentInfo.scopeId.startsWith(`${name}_`)) {
+      return parentEl;
+    }
+  }
+  const scopeId = getScopeId(parentEl);
+  if (scopeId) {
+    if (scopeId.startsWith(`${name}_`) || /_s\d/.test(scopeId) && parent !== document) {
+      hydratedScopes.add(parentEl);
+      return parent;
+    }
+  }
+  const searchRoot = parent || document;
+  const allScopes = Array.from(searchRoot.querySelectorAll(`[${BF_SCOPE}^="${name}_"]`));
+  const uninitializedScopes = allScopes.filter((s) => !hydratedScopes.has(s));
+  const scope = uninitializedScopes[idx] || null;
+  if (scope) {
+    hydratedScopes.add(scope);
+    return scope;
+  }
+  if (comment) {
+    return findScopeByComment(name, idx, searchRoot);
+  }
+  return null;
+}
+function findScopeByComment(name, idx, searchRoot) {
+  const prefix = BF_SCOPE_COMMENT_PREFIX;
+  const walker = document.createTreeWalker(searchRoot, NodeFilter.SHOW_COMMENT);
+  let matchIdx = 0;
+  while (walker.nextNode()) {
+    const comment = walker.currentNode;
+    const value = comment.nodeValue;
+    if (!value?.startsWith(prefix))
+      continue;
+    const scopeId = parseCommentScopeId(value, prefix);
+    if (!scopeId?.startsWith(`${name}_`))
+      continue;
+    if (initializedComments.has(comment))
+      continue;
+    if (matchIdx === idx) {
+      initializedComments.add(comment);
+      const proxyEl = nextElementSibling(comment) ?? comment.parentElement;
+      if (proxyEl) {
+        commentScopeRegistry.set(proxyEl, { commentNode: comment, scopeId });
+      }
+      return proxyEl;
+    }
+    matchIdx++;
+  }
+  return null;
+}
+function* candidatesInScope(scope, selector) {
+  const commentInfo = commentScopeRegistry.get(scope);
+  if (commentInfo) {
+    const boundary = getCommentScopeBoundary(commentInfo.commentNode);
+    let node = commentInfo.commentNode.nextSibling;
+    while (node && node !== boundary) {
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        const el = node;
+        if (el.matches?.(selector))
+          yield el;
+        yield* el.querySelectorAll(selector);
+      }
+      node = node.nextSibling;
+    }
+    return;
+  }
+  yield* scope.querySelectorAll(selector);
+  const scopeId = scope.getAttribute(BF_SCOPE);
+  if (!scopeId)
+    return;
+  const parent = scope.parentElement;
+  if (!parent)
+    return;
+  const siblings = parent.querySelectorAll(`[${BF_SCOPE}="${scopeId}"]`);
+  for (const sibling of siblings) {
+    if (sibling === scope)
+      continue;
+    if (sibling.matches?.(selector))
+      yield sibling;
+    yield* sibling.querySelectorAll(selector);
+  }
+}
+function belongsToScope(element, scope) {
+  if (element.getAttribute(BF_SCOPE))
+    return false;
+  const nearestScope = element.closest(`[${BF_SCOPE}]`);
+  return nearestScope === scope;
+}
+function isInCommentScopeRange(element, commentNode) {
+  const boundary = getCommentScopeBoundary(commentNode);
+  let node = commentNode.nextSibling;
+  while (node && node !== boundary) {
+    if (node === element || node.nodeType === Node.ELEMENT_NODE && node.contains(element)) {
+      return true;
+    }
+    node = node.nextSibling;
+  }
+  return false;
+}
+function find(scope, selector, ignoreScope) {
+  if (!scope)
+    return null;
+  const commentInfo = commentScopeRegistry.get(scope);
+  if (!commentInfo && scope.matches?.(selector))
+    return scope;
+  for (const candidate of candidatesInScope(scope, selector)) {
+    if (ignoreScope)
+      return candidate;
+    if (commentInfo) {
+      if (candidate.parentElement === commentInfo.commentNode.parentElement)
+        return candidate;
+      if (!candidate.closest(`[${BF_SCOPE}]`))
+        return candidate;
+    } else {
+      if (belongsToScope(candidate, scope))
+        return candidate;
+    }
+  }
+  const scopeId = commentInfo?.scopeId ?? getScopeId(scope);
+  if (scopeId)
+    return findInPortals(scopeId, selector);
+  return null;
+}
+function findInPortals(scopeId, selector) {
+  const portals = document.querySelectorAll(`[${BF_PORTAL_OWNER}="${scopeId}"]`);
+  for (const portal of portals) {
+    if (portal.matches?.(selector))
+      return portal;
+    const matches = portal.querySelectorAll(selector);
+    for (const match of matches) {
+      const nearestScope = match.closest(`[${BF_SCOPE}]`);
+      if (!nearestScope) {
+        return match;
+      }
+    }
+  }
+  return null;
+}
+function qsa(el, selector) {
+  if (!el)
+    return null;
+  if (selector.includes(",")) {
+    for (const clause of splitTopLevelCommas(selector)) {
+      const c = clause.trim();
+      if (!c)
+        continue;
+      const hit = qsa(el, c);
+      if (hit)
+        return hit;
+    }
+    return null;
+  }
+  if (SLOT_SUFFIX_SELECTOR.test(selector)) {
+    return qsaChildScope(el, selector);
+  }
+  if (el.matches(selector))
+    return el;
+  return el.querySelector(selector);
+}
+function splitTopLevelCommas(selector) {
+  const out = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0;i < selector.length; i++) {
+    const ch = selector.charCodeAt(i);
+    if (ch === 91 || ch === 40)
+      depth++;
+    else if (ch === 93 || ch === 41)
+      depth--;
+    else if (ch === 44 && depth === 0) {
+      out.push(selector.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(selector.slice(start));
+  return out;
+}
+var SLOT_SUFFIX_SELECTOR = /^\[bf-s\$="_s\d+"\]$/;
+var NESTED_SLOT_SUFFIX = /_s\d+_s\d+$/;
+function qsaChildScope(scope, selector) {
+  if (scope.matches(selector)) {
+    const bfs = scope.getAttribute(BF_SCOPE) || "";
+    if (!NESTED_SLOT_SUFFIX.test(bfs))
+      return scope;
+  }
+  for (const candidate of scope.querySelectorAll(selector)) {
+    const bfs = candidate.getAttribute(BF_SCOPE) || "";
+    if (!NESTED_SLOT_SUFFIX.test(bfs))
+      return candidate;
+  }
+  return null;
+}
+function qsaChildScopes(scope, selector) {
+  const out = [];
+  for (const candidate of scope.querySelectorAll(selector)) {
+    const bfs = candidate.getAttribute(BF_SCOPE) || "";
+    if (!NESTED_SLOT_SUFFIX.test(bfs))
+      out.push(candidate);
+  }
+  return out;
+}
+function $(scope, ...ids) {
+  return ids.map((id) => {
+    const ignoreScope = id.startsWith(BF_PARENT_OWNED_PREFIX);
+    return find(scope, `[${BF_SLOT}="${id}"]`, ignoreScope || undefined);
+  });
+}
+function $c(scope, ...ids) {
+  return ids.map((id) => $cSingle(scope, id));
+}
+function $cSingle(scope, id) {
+  if (!scope)
+    return null;
+  const cleanId = id.startsWith(BF_PARENT_OWNED_PREFIX) ? id.slice(1) : id;
+  if (!/^s\d/.test(cleanId)) {
+    return findChildScope(scope, `[${BF_SCOPE}^="${cleanId}_"]`);
+  }
+  const parentScopeIds = getDualScopeIds(scope);
+  if (parentScopeIds.length > 0) {
+    for (const parentId of parentScopeIds) {
+      const result = findChildScope(scope, `[${BF_SCOPE}$="${parentId}_${cleanId}"]`);
+      if (result)
+        return result;
+    }
+    if (scope.matches?.(`[${BF_SCOPE}$="_${cleanId}"]`))
+      return scope;
+    return null;
+  }
+  return findChildScope(scope, `[${BF_SCOPE}$="_${cleanId}"]`);
+}
+function findChildScope(scope, selector) {
+  if (scope.matches?.(selector))
+    return scope;
+  for (const candidate of candidatesInScope(scope, selector)) {
+    return candidate;
+  }
+  const commentInfo = commentScopeRegistry.get(scope);
+  const scopeId = commentInfo?.scopeId ?? getScopeId(scope);
+  if (scopeId)
+    return findInPortals(scopeId, selector);
+  return null;
+}
+function getDualScopeIds(scope) {
+  if (!scope)
+    return [];
+  const bfScopeId = getScopeId(scope);
+  const commentInfo = commentScopeRegistry.get(scope);
+  const commentScopeId = commentInfo?.scopeId ?? null;
+  if (commentScopeId && bfScopeId && commentScopeId !== bfScopeId) {
+    return [commentScopeId, bfScopeId];
+  }
+  const id = commentScopeId ?? bfScopeId;
+  return id ? [id] : [];
+}
+function $t(scope, ...ids) {
+  const results = new Array(ids.length).fill(null);
+  if (!scope)
+    return results;
+  const commentInfo = commentScopeRegistry.get(scope);
+  const searchRoot = commentInfo ? commentInfo.commentNode.parentNode ?? scope : scope;
+  const isComponentScope = scope.hasAttribute(BF_SCOPE) || commentInfo != null;
+  const markerMap = new Map;
+  for (let i = 0;i < ids.length; i++) {
+    markerMap.set(`bf:${ids[i]}`, {
+      index: i,
+      isParentOwned: ids[i].startsWith(BF_PARENT_OWNED_PREFIX)
+    });
+  }
+  let remaining = ids.length;
+  const walker = document.createTreeWalker(searchRoot, NodeFilter.SHOW_COMMENT);
+  while (walker.nextNode() && remaining > 0) {
+    const comment = walker.currentNode;
+    const entry = markerMap.get(comment.nodeValue ?? "");
+    if (!entry || results[entry.index] !== null)
+      continue;
+    if (isComponentScope && !entry.isParentOwned && !commentBelongsToScope(comment, scope, commentInfo)) {
+      continue;
+    }
+    results[entry.index] = textNodeAfterComment(comment);
+    remaining--;
+  }
+  return results;
+}
+function textNodeAfterComment(comment) {
+  const next = comment.nextSibling;
+  if (next?.nodeType === Node.TEXT_NODE) {
+    return next;
+  }
+  const textNode = document.createTextNode("");
+  comment.parentNode?.insertBefore(textNode, comment.nextSibling);
+  return textNode;
+}
+function commentBelongsToScope(comment, scope, commentInfo) {
+  const parent = comment.parentElement;
+  if (!parent)
+    return false;
+  const parentScope = parent.closest(`[${BF_SCOPE}]`);
+  if (parentScope === scope)
+    return true;
+  if (commentInfo) {
+    return isInCommentScopeRange(parent, commentInfo.commentNode);
+  }
+  return false;
+}
+
+// src/runtime/slot-resolver.ts
+function parentScopeOf(parent, anchorScope) {
+  const ancestor = anchorScope ?? parent.closest(`[${BF_SCOPE}]`);
+  if (!ancestor)
+    return "";
+  return ancestor.getAttribute(BF_SCOPE) ?? "";
+}
+function buildSlotInfo(parent, slotId, anchorScope) {
+  return { parent: parentScopeOf(parent, anchorScope), mount: slotId };
+}
+function findSsrScopeBySlotIn(parent, slotId, anchorScope, selfMatch) {
+  const parentBfs = parentScopeOf(parent, anchorScope);
+  if (parentBfs) {
+    const selector = `[${BF_HOST}="${cssEscape(parentBfs)}"][${BF_AT}="${slotId}"]`;
+    if (selfMatch && parent.matches(selector))
+      return parent;
+    const direct = parent.querySelector(selector);
+    if (direct)
+      return direct;
+  }
+  const suffixSelector = `[${BF_SCOPE}$="_${slotId}"]`;
+  if (selfMatch && parent.matches(suffixSelector))
+    return parent;
+  return parent.querySelector(suffixSelector);
+}
+
+// src/runtime/registry.ts
+var componentRegistry = new Map;
+var pendingChildInits = new Map;
+function registerComponent(name, init) {
+  componentRegistry.set(name, init);
+  const pending = pendingChildInits.get(name);
+  if (pending) {
+    pendingChildInits.delete(name);
+    for (const { scope, props } of pending) {
+      initChild(name, scope, props);
+    }
+  }
+}
+function getComponentInit(name) {
+  return componentRegistry.get(name);
+}
+function initChild(name, childScope, props = {}) {
+  if (!childScope)
+    return;
+  const init = componentRegistry.get(name);
+  if (!init) {
+    if (!pendingChildInits.has(name)) {
+      pendingChildInits.set(name, []);
+    }
+    pendingChildInits.get(name).push({ scope: childScope, props });
+    return;
+  }
+  if (hydratedScopes.has(childScope) && childScope.hasAttribute(BF_HOST)) {
+    return;
+  }
+  const prevScope = setCurrentScope(childScope);
+  try {
+    init(childScope, props);
+  } finally {
+    setCurrentScope(prevScope);
+  }
+  hydratedScopes.add(childScope);
+}
+function upsertChild(parent, name, slotId, props, key, anchorScope) {
+  let ssr = null;
+  if (slotId) {
+    ssr = findSsrScopeBySlotIn(parent, slotId, anchorScope, false);
+  } else {
+    ssr = parent.querySelector(`[${BF_SCOPE}^="${name}_"]`);
+  }
+  if (ssr) {
+    initChild(name, ssr, props);
+    return ssr;
+  }
+  const phId = slotId ?? name;
+  const ph = parent.querySelector(`[data-bf-ph="${phId}"]`);
+  if (ph) {
+    const slot = slotId ? buildSlotInfo(parent, slotId, anchorScope) : undefined;
+    const comp = createComponent(name, props, key, slot);
+    ph.replaceWith(comp);
+    return comp;
+  }
+  return null;
+}
+
+// src/runtime/hydrate.ts
+var registeredDefs = new Map;
+function getRegisteredDef(name) {
+  return registeredDefs.get(name);
+}
+var microtaskScheduled = false;
+var rafScheduled = false;
+var scheduleMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : (cb) => {
+  Promise.resolve().then(cb);
+};
+function scheduleWalk() {
+  if (!microtaskScheduled) {
+    microtaskScheduled = true;
+    scheduleMicrotask(() => {
+      if (!microtaskScheduled)
+        return;
+      microtaskScheduled = false;
+      walkAllInDocumentOrder();
+    });
+  }
+  if (!rafScheduled && typeof requestAnimationFrame === "function") {
+    rafScheduled = true;
+    requestAnimationFrame(() => {
+      if (!rafScheduled)
+        return;
+      rafScheduled = false;
+      walkAllInDocumentOrder();
+    });
+  }
+}
+function hydrate(name, def) {
+  def.name = name;
+  registeredDefs.set(name, def);
+  registerComponent(name, def.init);
+  if (def.template) {
+    registerTemplate(name, def.template);
+  }
+  scheduleWalk();
+}
+function rehydrateAll() {
+  scheduleWalk();
+}
+function flushHydration() {
+  if (!microtaskScheduled && !rafScheduled)
+    return;
+  microtaskScheduled = false;
+  rafScheduled = false;
+  walkAllInDocumentOrder();
+}
+function walkAllInDocumentOrder() {
+  if (typeof document === "undefined")
+    return;
+  const walker = document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT);
+  while (walker.nextNode()) {
+    const node = walker.currentNode;
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      hydrateElementScope(node);
+    } else if (node.nodeType === Node.COMMENT_NODE) {
+      hydrateCommentScope(node);
+    }
+  }
+}
+function scopeName(id) {
+  const idx = id.indexOf("_");
+  return idx < 0 ? null : id.slice(0, idx);
+}
+function parseProps(json, where) {
+  if (!json)
+    return {};
+  try {
+    return JSON.parse(json);
+  } catch {
+    console.warn(`[BarefootJS] Invalid props JSON on ${where}:`, json);
+    return {};
+  }
+}
+function runInit(scope, def, props) {
+  const prevScope = setCurrentScope(scope);
+  try {
+    def.init(scope, props);
+  } finally {
+    setCurrentScope(prevScope);
+  }
+}
+function hydrateElementScope(el) {
+  if (hydratedScopes.has(el))
+    return;
+  const bfs = el.getAttribute(BF_SCOPE);
+  if (!bfs)
+    return;
+  if (el.hasAttribute(BF_HOST))
+    return;
+  const name = scopeName(bfs);
+  if (!name)
+    return;
+  const def = registeredDefs.get(name);
+  if (!def)
+    return;
+  hydratedScopes.add(el);
+  if (def.comment)
+    return;
+  runInit(el, def, parseProps(el.getAttribute(BF_PROPS), bfs));
+}
+function hydrateCommentScope(comment) {
+  const value = comment.nodeValue;
+  if (!value?.startsWith(BF_SCOPE_COMMENT_PREFIX))
+    return;
+  const rest = value.slice(BF_SCOPE_COMMENT_PREFIX.length);
+  if (rest.includes("|h="))
+    return;
+  const flagged = comment;
+  if (flagged.__bfInitialized)
+    return;
+  const pipeIdx = rest.indexOf("|");
+  const scopeId = pipeIdx >= 0 ? rest.slice(0, pipeIdx) : rest;
+  const propsJson = pipeIdx >= 0 ? rest.slice(pipeIdx + 1) : "";
+  const name = scopeName(scopeId);
+  if (!name)
+    return;
+  const def = registeredDefs.get(name);
+  if (!def?.comment)
+    return;
+  flagged.__bfInitialized = true;
+  const proxyEl = nextElementSibling2(comment) ?? comment.parentElement;
+  if (!proxyEl)
+    return;
+  commentScopeRegistry.set(proxyEl, { commentNode: comment, scopeId });
+  const parsed = parseProps(propsJson || null, `comment scope ${scopeId}`);
+  const props = parsed[name] ?? {};
+  runInit(proxyEl, def, props);
+}
+function nextElementSibling2(node) {
+  let sibling = node.nextSibling;
+  while (sibling) {
+    if (sibling.nodeType === Node.ELEMENT_NODE)
+      return sibling;
+    sibling = sibling.nextSibling;
+  }
+  return null;
+}
+
+// src/runtime/component.ts
+var _parentScopeId = null;
+function setParentScopeId(id) {
+  _parentScopeId = id;
+}
+var propsUpdateMap = new WeakMap;
+var propsMap = new WeakMap;
+function createComponent(nameOrDef, props, key, slot) {
+  if (typeof nameOrDef !== "string") {
+    return createComponentFromDef(nameOrDef, props, key);
+  }
+  const name = nameOrDef;
+  const templateFn = getTemplate(name);
+  if (!templateFn) {
+    console.warn(`[BarefootJS] Template not found for component: ${name}`);
+    return createPlaceholder(name, key);
+  }
+  const childrenDescriptor = Object.getOwnPropertyDescriptor(props, "children");
+  const childrenIsGetter = childrenDescriptor != null && typeof childrenDescriptor.get === "function";
+  const unwrappedProps = untrack(() => {
+    const result = {};
+    for (const k of Object.keys(props)) {
+      if (k === "children" && childrenIsGetter) {
+        result.children = "";
+        continue;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(props, k);
+      if (descriptor && typeof descriptor.get === "function") {
+        result[k] = descriptor.get();
+      } else {
+        result[k] = props[k];
+      }
+    }
+    if (Array.isArray(result.children) && !hasDomElements(result.children)) {
+      result.children = result.children.flat().map((c) => c == null ? "" : String(c)).join("");
+    }
+    return result;
+  });
+  const prevParentScopeId = _parentScopeId;
+  if (slot?.parent) {
+    _parentScopeId = slot.parent;
+  }
+  let html;
+  try {
+    html = templateFn(unwrappedProps);
+  } finally {
+    _parentScopeId = prevParentScopeId;
+  }
+  const element = parseHTML(html.trim()).firstChild;
+  if (!element) {
+    console.warn(`[BarefootJS] Template returned empty HTML for component: ${name}`);
+    return createPlaceholder(name, key);
+  }
+  const def = getRegisteredDef(name);
+  const isCommentWrapper = def?.comment === true;
+  if (!isCommentWrapper) {
+    element.setAttribute(BF_SCOPE, `${name}_${generateId()}`);
+  }
+  if (slot) {
+    if (slot.parent)
+      element.setAttribute(BF_HOST, slot.parent);
+    element.setAttribute(BF_AT, slot.mount);
+  }
+  if (key !== undefined) {
+    element.setAttribute(BF_KEY, String(key));
+  }
+  const prevScope = setCurrentScope(element);
+  const initFn = getComponentInit(name);
+  if (initFn) {
+    initFn(element, props);
+  }
+  if (childrenIsGetter) {
+    const children = untrack(() => childrenDescriptor.get());
+    if (children != null) {
+      insertGetterChildren(element, children);
+    }
+  }
+  setCurrentScope(prevScope);
+  hydratedScopes.add(element);
+  propsMap.set(element, props);
+  registerPropsUpdate(element, name, props);
+  return element;
+}
+function getComponentProps(element) {
+  return propsMap.get(element);
+}
+function registerPropsUpdate(element, name, _initialProps) {
+  propsUpdateMap.set(element, (newProps) => {
+    const init = getComponentInit(name);
+    if (init) {
+      init(element, newProps);
+    }
+  });
+}
+function getPropsUpdateFn(element) {
+  return propsUpdateMap.get(element);
+}
+function renderChild(name, props, key, slotSuffix) {
+  const templateFn = getTemplate(name);
+  const suffix = slotSuffix ? `_${slotSuffix}` : "";
+  const scopePrefix = _parentScopeId && slotSuffix ? _parentScopeId : `${name}_${generateId()}`;
+  const keyAttr = key !== undefined ? ` ${BF_KEY}="${key}"` : "";
+  const slotAttrs = _parentScopeId && slotSuffix ? ` ${BF_HOST}="${_parentScopeId}" ${BF_AT}="${slotSuffix}"` : "";
+  const bfsAttr = `${BF_SCOPE}="${scopePrefix}${suffix}"`;
+  if (!templateFn) {
+    return `<div ${bfsAttr}${slotAttrs}${keyAttr}></div>`;
+  }
+  let html = templateFn(props).trim().replace(PLACEHOLDER_ATTR_PATTERN, _parentScopeId ? ` bf-s="${_parentScopeId}"` : "");
+  const firstElMatch = html.match(/<(\w+)/);
+  if (!firstElMatch)
+    return html;
+  const insertPos = firstElMatch.index;
+  const afterInsert = html.slice(insertPos);
+  const extraAttrs = `${slotAttrs}${keyAttr}`;
+  if (ROOT_HAS_BFS_PATTERN.test(afterInsert)) {
+    if (!extraAttrs)
+      return html;
+    return html.slice(0, insertPos) + afterInsert.replace(/^(<\w+)/, `$1${extraAttrs}`);
+  }
+  return html.slice(0, insertPos) + afterInsert.replace(/^(<\w+)/, `$1 ${bfsAttr}${extraAttrs}`);
+}
+var PLACEHOLDER_ATTR_PATTERN = new RegExp(`\\s+bf-s="${BF_PARENT_SCOPE_PLACEHOLDER}"`, "g");
+var ROOT_HAS_BFS_PATTERN = /^<\w+[^>]*\sbf-s="/;
+function generateId() {
+  return Math.random().toString(36).slice(2, 8);
+}
+function createPlaceholder(name, key) {
+  const el = document.createElement("div");
+  el.setAttribute(BF_SCOPE, `${name}_placeholder`);
+  if (key !== undefined) {
+    el.setAttribute(BF_KEY, String(key));
+  }
+  el.textContent = `[${name}]`;
+  el.style.cssText = "color: red; border: 1px dashed red; padding: 4px;";
+  return el;
+}
+function unwrapPropsForTemplate(props) {
+  const result = {};
+  for (const key of Object.keys(props)) {
+    const descriptor = Object.getOwnPropertyDescriptor(props, key);
+    if (descriptor && typeof descriptor.get === "function") {
+      result[key] = descriptor.get();
+    } else {
+      result[key] = props[key];
+    }
+  }
+  if (Array.isArray(result.children) && !hasDomElements(result.children)) {
+    result.children = result.children.flat().map((c) => c == null ? "" : String(c)).join("");
+  }
+  return result;
+}
+function escapeAttrGt(html) {
+  return html.replace(/"[^"]*"/g, (match) => match.replace(/>/g, "&gt;"));
+}
+var SVG_NS = "http://www.w3.org/2000/svg";
+function parseHTML(html, parent) {
+  const tpl = document.createElement("template");
+  const escaped = escapeAttrGt(html);
+  if (parent && parent.namespaceURI === SVG_NS) {
+    tpl.innerHTML = `<svg>${escaped}</svg>`;
+    const wrapper = tpl.content.firstElementChild;
+    const frag = document.createDocumentFragment();
+    if (wrapper) {
+      while (wrapper.firstChild)
+        frag.appendChild(wrapper.firstChild);
+    }
+    return frag;
+  }
+  tpl.innerHTML = escaped;
+  return tpl.content;
+}
+function hasDomElements(value) {
+  if (value instanceof Element)
+    return true;
+  if (Array.isArray(value))
+    return value.some(hasDomElements);
+  return false;
+}
+function insertGetterChildren(element, children) {
+  if (children instanceof Element) {
+    element.appendChild(children);
+  } else if (Array.isArray(children)) {
+    for (const child of children.flat()) {
+      if (child instanceof Element) {
+        element.appendChild(child);
+      } else if (typeof child === "string" && child.length > 0) {
+        element.appendChild(parseHTML(child.trim()));
+      } else if (typeof child === "number") {
+        element.appendChild(document.createTextNode(String(child)));
+      }
+    }
+  } else if (typeof children === "string" && children.length > 0) {
+    element.appendChild(parseHTML(children.trim()));
+  } else if (typeof children === "number") {
+    element.appendChild(document.createTextNode(String(children)));
+  }
+}
+function createComponentFromDef(def, props, key) {
+  if (!def.template) {
+    throw new Error("[BarefootJS] createComponent with ComponentDef requires a template function");
+  }
+  const unwrappedProps = unwrapPropsForTemplate(props);
+  const html = def.template(unwrappedProps);
+  const element = parseHTML(html.trim()).firstChild;
+  if (!element) {
+    const el = document.createElement("div");
+    el.textContent = "[ComponentDef]";
+    el.style.cssText = "color: red; border: 1px dashed red; padding: 4px;";
+    return el;
+  }
+  const name = def.name || def.init.name?.replace(/^init/, "") || "Component";
+  const scopeId = `${name}_${generateId()}`;
+  element.setAttribute(BF_SCOPE, scopeId);
+  if (key !== undefined) {
+    element.setAttribute(BF_KEY, String(key));
+  }
+  def.init(element, props);
+  hydratedScopes.add(element);
+  propsMap.set(element, props);
+  return element;
+}
+
+// src/runtime/portal.ts
+function isSSRPortal(element) {
+  return element.closest(`[${BF_PORTAL_ID}]`) !== null;
+}
+function findSiblingSlot(el, slotSelector) {
+  const direct = el.parentElement?.querySelector(slotSelector);
+  if (direct)
+    return direct;
+  const portalWrapper = el.closest(`[${BF_PORTAL_ID}]`);
+  if (!portalWrapper)
+    return null;
+  const ownerScopeId = portalWrapper.getAttribute(BF_PORTAL_OWNER);
+  if (!ownerScopeId)
+    return null;
+  const ownerScope = document.querySelector(`[${BF_SCOPE}="${ownerScopeId}"]`);
+  if (!ownerScope)
+    return null;
+  return ownerScope.querySelector(slotSelector);
+}
+function cleanupPortalPlaceholder(portalId) {
+  const placeholder = document.querySelector(`template[${BF_PORTAL_PLACEHOLDER}="${portalId}"]`);
+  placeholder?.remove();
+}
+function createPortal(children, container = document.body, options) {
+  let element;
+  if (children instanceof HTMLElement) {
+    element = children;
+  } else {
+    const html = typeof children === "string" ? children : children.toString();
+    const parsed = parseHTML(html).firstElementChild;
+    if (!parsed) {
+      throw new Error("createPortal: Invalid HTML provided");
+    }
+    element = parsed;
+  }
+  if (options?.ownerScope) {
+    let scopeId = options.ownerScope.getAttribute?.(BF_SCOPE) ?? null;
+    if (!scopeId) {
+      scopeId = getPortalScopeId(options.ownerScope) ?? null;
+    }
+    if (scopeId) {
+      element.setAttribute(BF_PORTAL_OWNER, scopeId);
+    }
+  }
+  container.appendChild(element);
+  return {
+    element,
+    unmount() {
+      if (element.parentNode) {
+        element.parentNode.removeChild(element);
+      }
+    }
+  };
+}
+// src/runtime/reconcile-elements.ts
+function findLoopMarkers(container, markerId) {
+  let startMarker = null;
+  let endMarker = null;
+  if (markerId) {
+    const startVal = loopStartMarker(markerId);
+    const endVal = loopEndMarker(markerId);
+    for (const node of Array.from(container.childNodes)) {
+      if (node.nodeType !== Node.COMMENT_NODE)
+        continue;
+      const value = node.nodeValue;
+      if (value === startVal)
+        startMarker = node;
+      else if (value === endVal)
+        endMarker = node;
+    }
+  } else {
+    const startPrefix = `${BF_LOOP_START}:`;
+    const endPrefix = `${BF_LOOP_END}:`;
+    for (const node of Array.from(container.childNodes)) {
+      if (node.nodeType !== Node.COMMENT_NODE)
+        continue;
+      const value = node.nodeValue ?? "";
+      if (!startMarker && (value === BF_LOOP_START || value.startsWith(startPrefix))) {
+        startMarker = node;
+      } else if (!endMarker && (value === BF_LOOP_END || value.startsWith(endPrefix))) {
+        endMarker = node;
+      }
+    }
+  }
+  if (startMarker && endMarker)
+    return { startMarker, endMarker };
+  return { startMarker: null, endMarker: null };
+}
+function getElementsBetweenMarkers(start, end) {
+  const elements = [];
+  let node = start.nextSibling;
+  while (node && node !== end) {
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      elements.push(node);
+    }
+    node = node.nextSibling;
+  }
+  return elements;
+}
+function removeElementsBetweenMarkers(start, end) {
+  let node = start.nextSibling;
+  while (node && node !== end) {
+    const next = node.nextSibling;
+    node.parentNode?.removeChild(node);
+    node = next;
+  }
+}
+function getLoopChildren(container, markerId) {
+  const { startMarker, endMarker } = findLoopMarkers(container, markerId);
+  if (startMarker && endMarker) {
+    return getElementsBetweenMarkers(startMarker, endMarker);
+  }
+  return Array.from(container.children);
+}
+function getLoopNodes(container, markerId) {
+  const { startMarker, endMarker } = findLoopMarkers(container, markerId);
+  const nodes = [];
+  if (startMarker && endMarker) {
+    let node = startMarker.nextSibling;
+    while (node && node !== endMarker) {
+      nodes.push(node);
+      node = node.nextSibling;
+    }
+    return nodes;
+  }
+  return Array.from(container.childNodes);
+}
+function reconcileElements(container, items, getKey, renderItem, firstElement, markerId) {
+  if (!container || !items)
+    return;
+  const { startMarker, endMarker } = findLoopMarkers(container, markerId);
+  const existingByKey = new Map;
+  let hasKeyedChildren = false;
+  const loopChildren = startMarker ? getElementsBetweenMarkers(startMarker, endMarker) : Array.from(container.children);
+  for (const child of loopChildren) {
+    const el = child;
+    const key = el.dataset?.key;
+    if (key !== undefined) {
+      existingByKey.set(key, el);
+      hasKeyedChildren = true;
+    }
+  }
+  if (!hasKeyedChildren) {
+    if (items.length === 0) {
+      if (startMarker) {
+        removeElementsBetweenMarkers(startMarker, endMarker);
+      } else {
+        container.innerHTML = "";
+      }
+      return;
+    }
+    const fragment = document.createDocumentFragment();
+    for (let i = 0;i < items.length; i++) {
+      const el = i === 0 && firstElement ? firstElement : renderItem(items[i], i);
+      const key = getKey ? getKey(items[i], i) : String(i);
+      if (!el.dataset.key)
+        el.setAttribute(BF_KEY, key);
+      fragment.appendChild(el);
+    }
+    if (startMarker) {
+      removeElementsBetweenMarkers(startMarker, endMarker);
+      endMarker.parentNode.insertBefore(fragment, endMarker);
+    } else {
+      container.innerHTML = "";
+      container.appendChild(fragment);
+    }
+    return;
+  }
+  let insertAnchor = endMarker ?? null;
+  if (!startMarker) {
+    let foundKeyed = false;
+    for (const child of Array.from(container.childNodes)) {
+      if (child.nodeType === Node.ELEMENT_NODE && child.dataset.key !== undefined) {
+        foundKeyed = true;
+      } else if (foundKeyed) {
+        insertAnchor = child;
+        break;
+      }
+    }
+  }
+  let focusedKey = null;
+  const activeEl = document.activeElement;
+  if (activeEl && activeEl !== document.body) {
+    const tag = activeEl.tagName;
+    if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || activeEl.isContentEditable) {
+      for (const [key, el] of existingByKey) {
+        if (el.contains(activeEl)) {
+          focusedKey = key;
+          break;
+        }
+      }
+    }
+  }
+  const desiredElements = [];
+  const toRemove = [];
+  let focusTarget = null;
+  for (let i = 0;i < items.length; i++) {
+    const item = items[i];
+    const key = getKey ? getKey(item, i) : String(i);
+    const createEl = () => i === 0 && firstElement ? firstElement : renderItem(item, i);
+    const existing = existingByKey.get(key);
+    if (existing) {
+      existingByKey.delete(key);
+      if (existing.getAttribute(BF_SCOPE) && !hydratedScopes.has(existing)) {
+        const newEl = createEl();
+        if (!newEl.dataset.key)
+          newEl.setAttribute(BF_KEY, key);
+        desiredElements.push(newEl);
+        toRemove.push(existing);
+      } else if (focusedKey === key) {
+        const newEl = createEl();
+        if (!newEl.dataset.key)
+          newEl.setAttribute(BF_KEY, key);
+        focusTarget = prepareInputTransfer(existing, newEl);
+        desiredElements.push(newEl);
+        toRemove.push(existing);
+      } else {
+        const newEl = createEl();
+        if (!newEl.dataset.key)
+          newEl.setAttribute(BF_KEY, key);
+        desiredElements.push(newEl);
+        toRemove.push(existing);
+      }
+    } else {
+      const el = createEl();
+      if (!el.dataset.key)
+        el.setAttribute(BF_KEY, key);
+      desiredElements.push(el);
+    }
+  }
+  for (const el of existingByKey.values()) {
+    toRemove.push(el);
+  }
+  for (const el of toRemove) {
+    if (el.parentNode)
+      el.remove();
+  }
+  for (const el of desiredElements) {
+    container.insertBefore(el, insertAnchor);
+  }
+  if (focusTarget) {
+    focusTarget.target.focus();
+    if (typeof focusTarget.selectionStart === "number") {
+      focusTarget.target.selectionStart = focusTarget.selectionStart;
+      focusTarget.target.selectionEnd = focusTarget.selectionEnd;
+    }
+  }
+}
+function prepareInputTransfer(oldEl, newEl) {
+  const focused = oldEl.contains(document.activeElement) ? document.activeElement : null;
+  if (!focused)
+    return null;
+  const tag = focused.tagName;
+  const oldInputs = Array.from(oldEl.querySelectorAll(tag));
+  const idx = oldInputs.indexOf(focused);
+  if (idx < 0)
+    return null;
+  const newInputs = Array.from(newEl.querySelectorAll(tag));
+  const target = newInputs[idx];
+  if (!target)
+    return null;
+  target.value = focused.value;
+  return {
+    target,
+    selectionStart: focused.selectionStart,
+    selectionEnd: focused.selectionEnd
+  };
+}
+
+// src/runtime/list.ts
+function reconcileList(container, items, getKey, renderItem) {
+  if (!container || !items)
+    return;
+  if (items.length === 0) {
+    container.innerHTML = "";
+    return;
+  }
+  const firstElement = renderItem(items[0], 0);
+  reconcileElements(container, items, getKey, renderItem, firstElement);
+}
+// src/runtime/qsa-item.ts
+function* itemRootElements(primaryEl) {
+  yield primaryEl;
+  const startPrefix = `${BF_LOOP_START}:`;
+  const endPrefix = `${BF_LOOP_END}:`;
+  let n = primaryEl.nextSibling;
+  while (n) {
+    if (n.nodeType === Node.COMMENT_NODE) {
+      const v = n.nodeValue ?? "";
+      if (v === BF_LOOP_ITEM || v === BF_LOOP_START || v.startsWith(startPrefix) || v === BF_LOOP_END || v.startsWith(endPrefix)) {
+        return;
+      }
+    } else if (n.nodeType === Node.ELEMENT_NODE) {
+      yield n;
+    }
+    n = n.nextSibling;
+  }
+  const stashed = primaryEl.__bfExtras;
+  if (stashed) {
+    for (const ex of stashed)
+      yield ex;
+  }
+}
+function qsaItem(primaryEl, selector) {
+  if (!primaryEl)
+    return null;
+  for (const root of itemRootElements(primaryEl)) {
+    if (root.matches(selector))
+      return root;
+    const inner = root.querySelector(selector);
+    if (inner)
+      return inner;
+  }
+  return null;
+}
+function upsertChildItem(primaryEl, name, slotId, props, key, anchorScope) {
+  let ssr = null;
+  if (slotId) {
+    for (const root of itemRootElements(primaryEl)) {
+      const found = findSsrScopeBySlotIn(root, slotId, anchorScope, true);
+      if (found) {
+        ssr = found;
+        break;
+      }
+    }
+  } else {
+    ssr = qsaItem(primaryEl, `[bf-s^="${name}_"]`);
+  }
+  if (ssr) {
+    initChild(name, ssr, props);
+    return ssr;
+  }
+  const phId = slotId ?? name;
+  const ph = qsaItem(primaryEl, `[data-bf-ph="${phId}"]`);
+  if (ph) {
+    const slot = slotId ? buildSlotInfo(primaryEl, slotId, anchorScope) : undefined;
+    const comp = createComponent(name, props, key, slot);
+    ph.replaceWith(comp);
+    return comp;
+  }
+  return null;
+}
+// src/runtime/map-array.ts
+function findLoopMarkers2(container, markerId) {
+  let start = null;
+  let end = null;
+  if (markerId) {
+    const startVal = loopStartMarker(markerId);
+    const endVal = loopEndMarker(markerId);
+    for (const node of Array.from(container.childNodes)) {
+      if (node.nodeType !== Node.COMMENT_NODE)
+        continue;
+      const value = node.nodeValue;
+      if (value === startVal)
+        start = node;
+      else if (value === endVal)
+        end = node;
+    }
+  } else {
+    const startPrefix = `${BF_LOOP_START}:`;
+    const endPrefix = `${BF_LOOP_END}:`;
+    for (const node of Array.from(container.childNodes)) {
+      if (node.nodeType !== Node.COMMENT_NODE)
+        continue;
+      const value = node.nodeValue ?? "";
+      if (!start && (value === BF_LOOP_START || value.startsWith(startPrefix))) {
+        start = node;
+      } else if (!end && (value === BF_LOOP_END || value.startsWith(endPrefix))) {
+        end = node;
+      }
+    }
+  }
+  if (start && end)
+    return { start, end };
+  return { start: null, end: null };
+}
+function findItemRanges(start, end) {
+  const ranges = [];
+  let current = null;
+  let sawItemMarker = false;
+  let node = start.nextSibling;
+  while (node && node !== end) {
+    if (node.nodeType === Node.COMMENT_NODE && node.nodeValue === BF_LOOP_ITEM) {
+      sawItemMarker = true;
+      current = { startMarker: node, primaryEl: null, extras: [] };
+      ranges.push(current);
+    } else if (node.nodeType === Node.ELEMENT_NODE) {
+      const el = node;
+      if (sawItemMarker) {
+        if (!current.primaryEl)
+          current.primaryEl = el;
+        else
+          current.extras.push(el);
+      } else {
+        ranges.push({ startMarker: null, primaryEl: el, extras: [] });
+      }
+    }
+    node = node.nextSibling;
+  }
+  return ranges.filter((r) => r.primaryEl !== null);
+}
+function insertScope(scope, container, anchor) {
+  if (scope.startMarker)
+    container.insertBefore(scope.startMarker, anchor);
+  container.insertBefore(scope.primaryEl, anchor);
+  for (const ex of scope.extras)
+    container.insertBefore(ex, anchor);
+}
+function removeScope(scope) {
+  if (scope.startMarker?.parentNode)
+    scope.startMarker.remove();
+  if (scope.primaryEl.parentNode)
+    scope.primaryEl.remove();
+  for (const ex of scope.extras) {
+    if (ex.parentNode)
+      ex.remove();
+  }
+}
+function createItemScope(item, index, renderItem, existingPrimary, existingExtras, existingStart) {
+  let primaryEl;
+  let dispose;
+  let setItem;
+  let extras = [];
+  let startMarker = null;
+  createRoot((d) => {
+    dispose = d;
+    const [itemAccessor, itemSetter] = createSignal(item);
+    setItem = itemSetter;
+    primaryEl = renderItem(itemAccessor, index, existingPrimary);
+    if (existingPrimary) {
+      extras = existingExtras ?? [];
+      startMarker = existingStart ?? null;
+    } else {
+      const stashed = primaryEl.__bfExtras;
+      if (stashed && stashed.length > 0) {
+        extras = stashed;
+        startMarker = document.createComment(BF_LOOP_ITEM);
+      }
+      delete primaryEl.__bfExtras;
+    }
+    return;
+  });
+  return { startMarker, primaryEl, extras, dispose, setItem };
+}
+function mapArray(accessor, container, getKey, renderItem, markerId) {
+  if (!container)
+    return;
+  const scopes = new Map;
+  let hydrated = false;
+  createEffect(() => {
+    const items = accessor();
+    if (!items)
+      return;
+    const { start: startMarker, end: endMarker } = findLoopMarkers2(container, markerId);
+    const anchor = endMarker ?? null;
+    if (!hydrated) {
+      hydrated = true;
+      const existingRanges = startMarker ? findItemRanges(startMarker, endMarker) : Array.from(container.children).map((el) => ({ startMarker: null, primaryEl: el, extras: [] }));
+      const needsHydration = existingRanges.length > 0 && (!existingRanges[0]?.primaryEl.hasAttribute("data-key") || scopes.size === 0);
+      if (needsHydration) {
+        for (let i = 0;i < existingRanges.length && i < items.length; i++) {
+          const range = existingRanges[i];
+          const item = items[i];
+          const key = getKey ? getKey(item, i) : String(i);
+          range.primaryEl.setAttribute(BF_KEY, key);
+          const scope = createItemScope(item, i, renderItem, range.primaryEl, range.extras, range.startMarker);
+          scopes.set(key, scope);
+          hydratedScopes.add(range.primaryEl);
+        }
+        for (let i = existingRanges.length;i < items.length; i++) {
+          const item = items[i];
+          const key = getKey ? getKey(item, i) : String(i);
+          const scope = createItemScope(item, i, renderItem);
+          if (!scope.primaryEl.dataset.key)
+            scope.primaryEl.setAttribute(BF_KEY, key);
+          scopes.set(key, scope);
+          insertScope(scope, container, anchor);
+        }
+        return;
+      }
+    }
+    if (scopes.size === 0) {
+      const loopRanges = startMarker ? findItemRanges(startMarker, endMarker) : Array.from(container.children).map((el) => ({ startMarker: null, primaryEl: el, extras: [] }));
+      for (const range of loopRanges) {
+        const existingKey = range.primaryEl.dataset?.key;
+        if (existingKey && !scopes.has(existingKey)) {
+          scopes.set(existingKey, {
+            startMarker: range.startMarker,
+            primaryEl: range.primaryEl,
+            extras: range.extras,
+            dispose: () => {},
+            setItem: () => {}
+          });
+        }
+      }
+    }
+    const newKeys = new Set;
+    const warnedKeys = new Set;
+    const desiredOrder = [];
+    for (let i = 0;i < items.length; i++) {
+      const item = items[i];
+      const key = getKey ? getKey(item, i) : String(i);
+      if (newKeys.has(key) && !warnedKeys.has(key)) {
+        warnedKeys.add(key);
+        console.warn(`[BarefootJS] mapArray: duplicate key "${key}" — items with this key collapse to a single DOM scope, ` + `so only the last one renders. Use a per-item identifier (e.g. \`key={item.id}\`) for correct reconciliation.`);
+      }
+      newKeys.add(key);
+      const existing = scopes.get(key);
+      if (existing) {
+        existing.setItem(item);
+        desiredOrder.push(existing);
+      } else {
+        const scope = createItemScope(item, i, renderItem);
+        if (!scope.primaryEl.dataset.key)
+          scope.primaryEl.setAttribute(BF_KEY, key);
+        scopes.set(key, scope);
+        desiredOrder.push(scope);
+      }
+    }
+    for (const [key, scope] of scopes) {
+      if (!newKeys.has(key)) {
+        scope.dispose();
+        removeScope(scope);
+        scopes.delete(key);
+      }
+    }
+    let inOrder = true;
+    let checkNode = startMarker ? startMarker.nextSibling : container.firstChild;
+    for (const scope of desiredOrder) {
+      while (checkNode && checkNode.nodeType !== Node.ELEMENT_NODE)
+        checkNode = checkNode.nextSibling;
+      if (checkNode !== scope.primaryEl) {
+        inOrder = false;
+        break;
+      }
+      checkNode = checkNode.nextSibling;
+      for (let i = 0;i < scope.extras.length; i++) {
+        while (checkNode && checkNode.nodeType !== Node.ELEMENT_NODE)
+          checkNode = checkNode.nextSibling;
+        if (checkNode !== scope.extras[i]) {
+          inOrder = false;
+          break;
+        }
+        checkNode = checkNode.nextSibling;
+      }
+      if (!inOrder)
+        break;
+    }
+    if (!inOrder) {
+      for (const scope of desiredOrder) {
+        insertScope(scope, container, anchor);
+      }
+    }
+  });
+}
+// src/runtime/style.ts
+function styleToCss(value) {
+  if (value == null)
+    return null;
+  if (typeof value !== "object")
+    return String(value);
+  const parts = [];
+  for (const [k, v] of Object.entries(value)) {
+    if (v == null)
+      continue;
+    const prop = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    parts.push(`${prop}:${v}`);
+  }
+  return parts.join(";") || null;
+}
+
+// src/runtime/apply-rest-attrs.ts
+function toAttrName(key) {
+  if (key === "className")
+    return "class";
+  if (key === "htmlFor")
+    return "for";
+  return key.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+var jsxToDomEventMap = { doubleclick: "dblclick" };
+function toEventName(jsxPropName) {
+  const raw = (jsxPropName[2].toLowerCase() + jsxPropName.slice(3)).toLowerCase();
+  return jsxToDomEventMap[raw] ?? raw;
+}
+function applyRestAttrs(el, source, excludeKeys) {
+  const exclude = new Set(excludeKeys);
+  for (const key of Object.keys(source)) {
+    if (exclude.has(key))
+      continue;
+    if (key === "ref") {
+      const ref = source[key];
+      if (typeof ref === "function")
+        ref(el);
+      continue;
+    }
+    if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase()) {
+      const handler = source[key];
+      if (typeof handler === "function") {
+        el.addEventListener(toEventName(key), handler);
+      }
+    }
+  }
+  createEffect(() => {
+    for (const key of Object.keys(source)) {
+      if (exclude.has(key))
+        continue;
+      if (key === "ref")
+        continue;
+      if (key === "children")
+        continue;
+      if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase())
+        continue;
+      const value = source[key];
+      const attr = toAttrName(key);
+      if (value != null && value !== false) {
+        if (attr === "value" && "value" in el) {
+          const strVal = String(value);
+          if (el.value !== strVal)
+            el.value = strVal;
+        } else if (attr === "checked" && "checked" in el) {
+          el.checked = !!value;
+        } else if (attr === "style") {
+          const css = styleToCss(value);
+          if (css == null)
+            el.removeAttribute("style");
+          else
+            el.setAttribute("style", css);
+        } else {
+          el.setAttribute(attr, String(value));
+        }
+      } else {
+        if (attr === "checked" && "checked" in el) {
+          el.checked = false;
+        } else {
+          el.removeAttribute(attr);
+        }
+      }
+    }
+  });
+}
+// src/runtime/spread-attrs.ts
+var SVG_CAMEL_CASE_ATTRS = new Set([
+  "allowReorder",
+  "attributeName",
+  "attributeType",
+  "autoReverse",
+  "baseFrequency",
+  "baseProfile",
+  "calcMode",
+  "clipPathUnits",
+  "contentScriptType",
+  "contentStyleType",
+  "diffuseConstant",
+  "edgeMode",
+  "externalResourcesRequired",
+  "filterRes",
+  "filterUnits",
+  "glyphRef",
+  "gradientTransform",
+  "gradientUnits",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keyPoints",
+  "keySplines",
+  "keyTimes",
+  "lengthAdjust",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerUnits",
+  "markerWidth",
+  "maskContentUnits",
+  "maskUnits",
+  "numOctaves",
+  "pathLength",
+  "patternContentUnits",
+  "patternTransform",
+  "patternUnits",
+  "pointsAtX",
+  "pointsAtY",
+  "pointsAtZ",
+  "preserveAlpha",
+  "preserveAspectRatio",
+  "primitiveUnits",
+  "refX",
+  "refY",
+  "repeatCount",
+  "repeatDur",
+  "requiredExtensions",
+  "requiredFeatures",
+  "specularConstant",
+  "specularExponent",
+  "spreadMethod",
+  "startOffset",
+  "stdDeviation",
+  "stitchTiles",
+  "surfaceScale",
+  "systemLanguage",
+  "tableValues",
+  "targetX",
+  "targetY",
+  "textLength",
+  "viewBox",
+  "viewTarget",
+  "xChannelSelector",
+  "yChannelSelector",
+  "zoomAndPan"
+]);
+function spreadAttrs(obj) {
+  if (!obj || typeof obj !== "object")
+    return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value == null || value === false)
+      continue;
+    if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase())
+      continue;
+    if (key === "children")
+      continue;
+    if (key === "style") {
+      const css = styleToCss(value);
+      if (css != null)
+        parts.push(`style="${css}"`);
+      continue;
+    }
+    const attr = key === "className" ? "class" : key === "htmlFor" ? "for" : SVG_CAMEL_CASE_ATTRS.has(key) ? key : key.replace(/([A-Z])/g, "-$1").toLowerCase();
+    parts.push(value === true ? attr : `${attr}="${value}"`);
+  }
+  return parts.join(" ");
+}
+// src/runtime/insert.ts
+var EMPTY_SLOTS = [];
+function normalizeTemplate(value) {
+  return typeof value === "string" ? { html: value, slots: EMPTY_SLOTS } : value;
+}
+function evalBranchTemplate(branch) {
+  return untrack(() => normalizeTemplate(branch.template()));
+}
+function insert(scope, id, conditionFn, whenTrue, whenFalse) {
+  if (!scope)
+    return;
+  const parentScopeId = scope.getAttribute(BF_SCOPE);
+  let isFragmentCond = false;
+  try {
+    const sampleTrue = evalBranchTemplate(whenTrue);
+    isFragmentCond = sampleTrue.html.includes(`<!--bf-cond-start:${id}-->`);
+  } catch (err) {
+    if (!(err instanceof TypeError))
+      throw err;
+  }
+  if (!isFragmentCond) {
+    try {
+      const sampleFalse = evalBranchTemplate(whenFalse);
+      isFragmentCond = sampleFalse.html.includes(`<!--bf-cond-start:${id}-->`);
+    } catch (err) {
+      if (!(err instanceof TypeError))
+        throw err;
+    }
+  }
+  let prevCond;
+  let branchCleanup = null;
+  createEffect(() => {
+    let currCond;
+    try {
+      currCond = Boolean(conditionFn());
+    } catch (err) {
+      if (err instanceof TypeError) {
+        currCond = false;
+      } else {
+        throw err;
+      }
+    }
+    const isFirstRun = prevCond === undefined;
+    const prevVal = prevCond;
+    prevCond = currCond;
+    const branch = currCond ? whenTrue : whenFalse;
+    if (isFirstRun) {
+      setParentScopeId(parentScopeId);
+      let result2;
+      try {
+        result2 = evalBranchTemplate(branch);
+      } finally {
+        setParentScopeId(null);
+      }
+      const existingEl = find(scope, `[${BF_COND}="${id}"]`);
+      if (existingEl) {
+        const expectedSig = getTemplateRootSignature(result2.html);
+        const existingSig = existingEl.outerHTML.match(/^<[^>]+>/)?.[0] ?? null;
+        if (isFragmentCond && (!expectedSig || existingSig !== expectedSig)) {
+          updateFragmentConditional(scope, id, result2);
+        } else if (!isFragmentCond && expectedSig && existingSig && expectedSig !== existingSig) {
+          updateElementConditional(scope, id, result2);
+        } else if (result2.slots.length > 0) {
+          updateElementConditional(scope, id, result2);
+        }
+      } else if (isFragmentCond) {
+        updateFragmentConditional(scope, id, result2);
+      }
+      const cleanup2 = branch.bindEvents(scope, { isFirstRun: true });
+      branchCleanup = typeof cleanup2 === "function" ? cleanup2 : null;
+      autoFocusConditionalElement(scope, id);
+      return;
+    }
+    if (currCond === prevVal) {
+      return;
+    }
+    if (branchCleanup) {
+      branchCleanup();
+      branchCleanup = null;
+    }
+    setParentScopeId(parentScopeId);
+    let result;
+    try {
+      result = evalBranchTemplate(branch);
+    } finally {
+      setParentScopeId(null);
+    }
+    if (isFragmentCond) {
+      updateFragmentConditional(scope, id, result);
+    } else {
+      updateElementConditional(scope, id, result);
+    }
+    const cleanup = branch.bindEvents(scope, { isFirstRun: false });
+    branchCleanup = typeof cleanup === "function" ? cleanup : null;
+    autoFocusConditionalElement(scope, id);
+  });
+}
+function autoFocusConditionalElement(scope, id) {
+  requestAnimationFrame(() => {
+    const condEl = scope.querySelector(`[${BF_COND}="${id}"]`);
+    if (condEl) {
+      const autofocusEl = condEl.matches("[autofocus]") ? condEl : condEl.querySelector("[autofocus]");
+      if (autofocusEl && typeof autofocusEl.focus === "function") {
+        autofocusEl.focus();
+      }
+    }
+  });
+}
+function getTemplateRootSignature(template) {
+  const match = template.match(/^<[^>]+>/);
+  return match ? match[0] : null;
+}
+function spliceSlots(fragment, slots) {
+  if (slots.length === 0)
+    return fragment;
+  const walker = document.createTreeWalker(fragment, NodeFilter.SHOW_COMMENT);
+  const replacements = [];
+  while (walker.nextNode()) {
+    const c = walker.currentNode;
+    const m = c.nodeValue?.match(/^bf-slot:(\d+)$/);
+    if (m) {
+      const idx = Number(m[1]);
+      const node = slots[idx];
+      if (node)
+        replacements.push([c, node]);
+    }
+  }
+  for (const [marker, node] of replacements) {
+    marker.parentNode?.replaceChild(node, marker);
+  }
+  return fragment;
+}
+function updateFragmentConditional(scope, id, result) {
+  const { html, slots } = result;
+  const startMarker = `bf-cond-start:${id}`;
+  let startComment = null;
+  const walker = document.createTreeWalker(scope, NodeFilter.SHOW_COMMENT);
+  while (walker.nextNode()) {
+    if (walker.currentNode.nodeValue === startMarker) {
+      startComment = walker.currentNode;
+      break;
+    }
+  }
+  const condEl = scope.querySelector(`[${BF_COND}="${id}"]`);
+  const endMarker = `bf-cond-end:${id}`;
+  if (startComment) {
+    const nodesToRemove = [];
+    let node = startComment.nextSibling;
+    while (node && !(node.nodeType === 8 && node.nodeValue === endMarker)) {
+      nodesToRemove.push(node);
+      node = node.nextSibling;
+    }
+    const endComment = node;
+    nodesToRemove.forEach((n) => n.parentNode?.removeChild(n));
+    const insertParent = startComment.parentNode instanceof Element ? startComment.parentNode : null;
+    const fragment = spliceSlots(parseHTML(html, insertParent), slots);
+    let child = fragment.firstChild;
+    while (child) {
+      const next = child.nextSibling;
+      if (!(child.nodeType === 8 && child.nodeValue?.startsWith("bf-cond-"))) {
+        startComment.parentNode?.insertBefore(child, endComment);
+      }
+      child = next;
+    }
+  } else if (condEl) {
+    const insertParent = condEl.parentNode instanceof Element ? condEl.parentNode : null;
+    const parsed = spliceSlots(parseHTML(html, insertParent), slots);
+    const firstChild = parsed.firstChild;
+    if (firstChild?.nodeType === 8 && firstChild?.nodeValue === `bf-cond-start:${id}`) {
+      const parent = condEl.parentNode;
+      let n = parsed.firstChild;
+      while (n) {
+        const next = n.nextSibling;
+        parent?.insertBefore(n, condEl);
+        n = next;
+      }
+      condEl.remove();
+    } else if (firstChild) {
+      condEl.replaceWith(firstChild);
+    }
+  }
+}
+function updateElementConditional(scope, id, result) {
+  const condEl = scope.querySelector(`[${BF_COND}="${id}"]`);
+  if (!condEl)
+    return;
+  const { html, slots } = result;
+  const insertParent = condEl.parentNode instanceof Element ? condEl.parentNode : null;
+  const fragment = spliceSlots(parseHTML(html, insertParent), slots);
+  const newEl = fragment.firstChild;
+  if (newEl) {
+    condEl.replaceWith(newEl);
+  }
+}
+// src/runtime/branch-slot.ts
+function __bfSlot(value, slots) {
+  if (value == null || value === false || value === true)
+    return "";
+  if (typeof Node !== "undefined" && value instanceof Node) {
+    const idx = slots.length;
+    slots.push(value);
+    return `<!--bf-slot:${idx}-->`;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => __bfSlot(v, slots)).join("");
+  }
+  return String(value);
+}
+// src/runtime/client-marker.ts
+function updateClientMarker(scope, id, value) {
+  if (!scope)
+    return;
+  const marker = `bf-client:${id}`;
+  const walker = document.createTreeWalker(scope, NodeFilter.SHOW_COMMENT);
+  while (walker.nextNode()) {
+    if (walker.currentNode.nodeValue === marker) {
+      const comment = walker.currentNode;
+      let textNode = comment.nextSibling;
+      if (textNode?.nodeType !== Node.TEXT_NODE || !textNode.nodeValue?.startsWith("​")) {
+        textNode = document.createTextNode("​" + String(value ?? ""));
+        comment.parentNode?.insertBefore(textNode, comment.nextSibling);
+      } else {
+        textNode.nodeValue = "​" + String(value ?? "");
+      }
+      return;
+    }
+  }
+}
+// src/runtime/render.ts
+function render(container, nameOrDef, props = {}) {
+  let name;
+  let init;
+  let template;
+  if (typeof nameOrDef === "string") {
+    name = nameOrDef;
+    init = getComponentInit(name);
+    template = getTemplate(name);
+    if (!init || !template) {
+      throw new Error(`[BarefootJS] Component "${name}" is not registered. ` + `Did you import its .client.js file before calling render()?`);
+    }
+  } else {
+    init = nameOrDef.init;
+    template = nameOrDef.template;
+    name = nameOrDef.name || init.name?.replace(/^init/, "") || "Component";
+    if (!template) {
+      throw new Error("[BarefootJS] render(): ComponentDef requires a template function");
+    }
+  }
+  const scopeId = `${name}_${Math.random().toString(36).slice(2, 8)}`;
+  setParentScopeId(scopeId);
+  let html;
+  try {
+    html = template(props).trim();
+  } finally {
+    setParentScopeId(null);
+  }
+  const tpl = document.createElement("template");
+  tpl.innerHTML = html;
+  const element = tpl.content.firstChild;
+  if (!element) {
+    throw new Error("[BarefootJS] render(): template returned empty HTML");
+  }
+  if (!element.getAttribute(BF_SCOPE)) {
+    element.setAttribute(BF_SCOPE, scopeId);
+  }
+  container.innerHTML = "";
+  container.appendChild(element);
+  init(element, props);
+  hydratedScopes.add(element);
+}
+// src/runtime/streaming.ts
+function __bf_swap(id) {
+  const slot = document.querySelector(`[${BF_ASYNC}="${id}"]`);
+  const tmpl = document.querySelector(`template[${BF_ASYNC_RESOLVE}="${id}"]`);
+  if (!slot || !tmpl)
+    return;
+  slot.replaceChildren(tmpl.content.cloneNode(true));
+  slot.removeAttribute(BF_ASYNC);
+  tmpl.remove();
+  rehydrateAll();
+}
+function setupStreaming() {
+  if (typeof window === "undefined")
+    return;
+  const w = window;
+  w.__bf_swap = __bf_swap;
+  w.__bf_hydrate = rehydrateAll;
+}
+export {
+  useContext,
+  upsertChildItem,
+  upsertChild,
+  updateClientMarker,
+  unwrap,
+  untrack,
+  styleToCss,
+  spreadAttrs,
+  splitProps,
+  setupStreaming,
+  setCurrentScope,
+  renderChild,
+  render,
+  rehydrateAll,
+  registerTemplate,
+  registerComponent,
+  reconcileList,
+  reconcileElements,
+  qsaItem,
+  qsaChildScopes,
+  qsaChildScope,
+  qsa,
+  provideContext,
+  parseHTML,
+  onMount,
+  onCleanup,
+  mapArray,
+  isSSRPortal,
+  insert,
+  initChild,
+  hydratedScopes,
+  hydrate,
+  hasTemplate,
+  getTemplate,
+  getRegisteredDef,
+  getPropsUpdateFn,
+  getLoopNodes,
+  getLoopChildren,
+  getComponentProps,
+  getComponentInit,
+  forwardProps,
+  flushHydration,
+  findSiblingSlot,
+  findScope,
+  find,
+  cssEscape,
+  createSignal,
+  createRoot,
+  createPortal,
+  createMemo,
+  createEffect,
+  createDisposableEffect,
+  createContext,
+  createComponent,
+  cleanupPortalPlaceholder,
+  batch,
+  applyRestAttrs,
+  __slot,
+  __bf_swap,
+  __bfSlot,
+  $t,
+  $c,
+  $
+};