@vobs/ui 1.0.0 → 1.2.0

package/dist/index.js

@@ -0,0 +1,3234 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function setSignalDebugName(signal, name) {
+  signalNames.set(signal, name);
+  invokeDebug("signalNamed", signal, name);
+}
+__name(setSignalDebugName, "setSignalDebugName");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+var nextOwnerId = 1;
+var ownerNames = /* @__PURE__ */ new WeakMap();
+function createOwner() {
+  const parent = currentOwner;
+  let disposed = parent?.disposed ?? false;
+  const children = [];
+  const cleanups = [];
+  const errorHandlers = /* @__PURE__ */ new Set();
+  const owner = {
+    id: `owner-${nextOwnerId++}`,
+    parent,
+    children,
+    depth: (parent?.depth ?? -1) + 1,
+    get disposed() {
+      return disposed;
+    },
+    run(fn) {
+      if (disposed) throw new Error("Vobs: \u5DF2\u9500\u6BC1\u7684 Owner \u4E0D\u80FD\u7EE7\u7EED\u8FD0\u884C");
+      const previous = currentOwner;
+      currentOwner = owner;
+      try {
+        return fn();
+      } finally {
+        currentOwner = previous;
+      }
+    },
+    addCleanup(cleanup) {
+      if (disposed) {
+        cleanup();
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    onDispose(cleanup) {
+      owner.addCleanup(cleanup);
+    },
+    onError(handler) {
+      errorHandlers.add(handler);
+      const remove = /* @__PURE__ */ __name(() => errorHandlers.delete(handler), "remove");
+      owner.addCleanup(remove);
+      return remove;
+    },
+    handleError(error) {
+      for (const handler of [...errorHandlers].reverse()) {
+        try {
+          handler(error);
+          return true;
+        } catch (handlerError) {
+          return parent?.handleError(handlerError) ?? false;
+        }
+      }
+      return parent?.handleError(error) ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const child of [...children]) child.dispose();
+      children.length = 0;
+      let firstError;
+      for (let index = cleanups.length - 1; index >= 0; index--) {
+        try {
+          cleanups[index]();
+        } catch (error) {
+          firstError ?? (firstError = error);
+        }
+      }
+      cleanups.length = 0;
+      if (parent) {
+        const index = parent.children.indexOf(owner);
+        if (index >= 0) parent.children.splice(index, 1);
+      }
+      if (firstError) throw firstError;
+    }
+  };
+  if (parent && !parent.disposed) parent.children.push(owner);
+  return owner;
+}
+__name(createOwner, "createOwner");
+function setOwnerDebugName(owner, name) {
+  ownerNames.set(owner, name);
+}
+__name(setOwnerDebugName, "setOwnerDebugName");
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+function onDispose(cleanup) {
+  const owner = getCurrentOwner();
+  if (!owner) throw new Error("Vobs: onDispose \u5FC5\u987B\u5728 Owner \u4F5C\u7528\u57DF\u5185\u8C03\u7528");
+  owner.onDispose(cleanup);
+}
+__name(onDispose, "onDispose");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function setCurrentSubscriber(subscriber) {
+  currentSubscriber = subscriber;
+}
+__name(setCurrentSubscriber, "setCurrentSubscriber");
+function trackDependency(dependency) {
+  if (!currentSubscriber || currentSubscriber.disposed) return;
+  !currentSubscriber.dependencies.has(dependency);
+  currentSubscriber.dependencies.add(dependency);
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      const subscriber = getCurrentSubscriber();
+      if (subscriber && !subscriber.disposed) {
+        subscribers.add(subscriber);
+        trackDependency(signalInstance);
+      }
+      return value;
+    },
+    set value(nextValue) {
+      if (disposed || Object.is(value, nextValue)) return;
+      value = nextValue;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    // 与 `.value =` 赋值同一条路径：判等短路、debug hook、notify 全部一致。
+    // 以闭包实现，可安全地作为回调直接传递（无 this 绑定问题）。
+    set(next) {
+      signalInstance.value = next;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+    }
+  };
+  const owner = getCurrentOwner();
+  owner?.addCleanup(signalInstance.dispose);
+  if (debugName?.trim()) setSignalDebugName(signalInstance, debugName.trim());
+  return signalInstance;
+}
+__name(state, "state");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+var Scheduler = _Scheduler;
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+var scheduler = new Scheduler();
+
+// packages/reactivity/src/effect.ts
+var nextEffectOrder = 1;
+function cleanupDependencies(subscriber) {
+  for (const dependency of subscriber.dependencies) {
+    dependency.unsubscribe(subscriber);
+  }
+  subscriber.dependencies.clear();
+}
+__name(cleanupDependencies, "cleanupDependencies");
+function effect(callback) {
+  const owner = getCurrentOwner();
+  let cleanup;
+  let dirty = true;
+  let disposed = false;
+  const eff = {
+    order: nextEffectOrder++,
+    depth: owner?.depth ?? 0,
+    dependencies: /* @__PURE__ */ new Set(),
+    get disposed() {
+      return disposed;
+    },
+    notify() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.schedule(eff);
+    },
+    run() {
+      if (disposed || !dirty) return;
+      dirty = false;
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled2 = owner?.handleError(error) ?? false;
+          if (!handled2) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      const previous = getCurrentSubscriber();
+      setCurrentSubscriber(eff);
+      let thrown;
+      let handled = false;
+      try {
+        const result = owner ? owner.run(callback) : callback();
+        cleanup = typeof result === "function" ? result : void 0;
+      } catch (error) {
+        thrown = error;
+        handled = owner?.handleError(error) ?? false;
+        if (!handled) throw error;
+      } finally {
+        setCurrentSubscriber(previous);
+      }
+      if (cleanupError && !thrown) throw cleanupError;
+    },
+    scheduleLow() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.scheduleLow(eff);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dirty = false;
+      scheduler.remove(eff);
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled = owner?.handleError(error) ?? false;
+          if (!handled) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  owner?.addCleanup(eff.dispose);
+  eff.run();
+  return eff;
+}
+__name(effect, "effect");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+function readDebugValue(read) {
+  try {
+    return read();
+  } catch {
+    return "[Uninspectable]";
+  }
+}
+__name(readDebugValue, "readDebugValue");
+function describeDebugNode(node) {
+  if (!node || typeof node !== "object") return "node";
+  const value = node;
+  const name = typeof value.tagName === "string" ? value.tagName.toLowerCase() : typeof value.nodeName === "string" ? value.nodeName.toLowerCase() : "node";
+  const id = typeof value.id === "string" && value.id ? `#${value.id}` : "";
+  const className = typeof value.className === "string" && value.className ? `.${value.className.trim().split(/\s+/).filter(Boolean).join(".")}` : "";
+  return `${name}${id}${className}`;
+}
+__name(describeDebugNode, "describeDebugNode");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+function markHmrInstanceMounted(node, parent) {
+  const instance = hmrInstances.get(node);
+  if (instance) instance.parent = parent;
+}
+__name(markHmrInstanceMounted, "markHmrInstanceMounted");
+var hmrInstances = /* @__PURE__ */ new WeakMap();
+var nodeOwners = /* @__PURE__ */ new WeakMap();
+var eventBindings = /* @__PURE__ */ new WeakMap();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createText(content) {
+  return getRenderer().createText(content);
+}
+__name(createText, "createText");
+function createElement(tag) {
+  return getRenderer().createElement(tag);
+}
+__name(createElement, "createElement");
+function createComment(content) {
+  return getRenderer().createComment(content);
+}
+__name(createComment, "createComment");
+function insertBefore(parent, child, anchor) {
+  if (isVobsFragment(child)) {
+    child.mount(parent, isVobsFragment(anchor) ? anchor.start : anchor);
+    return;
+  }
+  getRenderer().insertBefore(parent, child, isVobsFragment(anchor) ? anchor.start : anchor);
+  markHmrInstanceMounted(child, parent);
+}
+__name(insertBefore, "insertBefore");
+function removeChild(parent, child) {
+  disposeNodeOwner(child);
+  if (isVobsFragment(child)) {
+    child.unmount(parent);
+    return;
+  }
+  getRenderer().removeChild(parent, child);
+}
+__name(removeChild, "removeChild");
+function setTextContent(node, content) {
+  getRenderer().setTextContent(node, content);
+}
+__name(setTextContent, "setTextContent");
+function setProperty(node, key, value) {
+  getRenderer().setProperty(node, key, value);
+}
+__name(setProperty, "setProperty");
+function setAttribute(node, key, value) {
+  getRenderer().setAttribute(node, key, value);
+}
+__name(setAttribute, "setAttribute");
+function addEventListener(node, event, handler) {
+  const renderer = getRenderer();
+  const owner = getCurrentOwner();
+  let bindings = eventBindings.get(node);
+  if (!bindings) {
+    bindings = /* @__PURE__ */ new Map();
+    eventBindings.set(node, bindings);
+  }
+  const previous = bindings.get(event);
+  if (previous && previous.original === handler && previous.owner === owner) return;
+  if (previous) renderer.removeEventListener(node, event, previous.handler);
+  const listener = owner ? (reason) => {
+    try {
+      owner.run(() => handler(reason));
+    } catch (error) {
+      const handled = owner.handleError(error);
+      invokeRuntimeDebug("error", {
+        error,
+        owner,
+        phase: "event",
+        handled,
+        recovery: handled ? "handled" : "propagated"
+      });
+      if (!handled) throw error;
+    }
+  } : handler;
+  const binding = { handler: listener, owner, original: handler };
+  bindings.set(event, binding);
+  renderer.addEventListener(node, event, listener);
+  owner?.onDispose(() => {
+    if (bindings?.get(event) !== binding) return;
+    bindings.delete(event);
+    renderer.removeEventListener(node, event, listener);
+  });
+}
+__name(addEventListener, "addEventListener");
+function createBlock(factory) {
+  const owner = createOwner();
+  setOwnerDebugName(owner, "dynamic");
+  let node;
+  try {
+    node = owner.run(factory);
+  } catch (error) {
+    owner.dispose();
+    throw error;
+  }
+  if (!node) {
+    owner.dispose();
+    return null;
+  }
+  associateNodeOwner(node, owner);
+  return node;
+}
+__name(createBlock, "createBlock");
+function associateNodeOwner(node, owner) {
+  nodeOwners.set(node, owner);
+}
+__name(associateNodeOwner, "associateNodeOwner");
+function disposeNodeOwner(node) {
+  const owner = nodeOwners.get(node);
+  if (!owner) return;
+  nodeOwners.delete(node);
+  owner.dispose();
+}
+__name(disposeNodeOwner, "disposeNodeOwner");
+
+// packages/runtime/src/fragment.ts
+function createFragment(factory) {
+  const start = createComment("vobs:fragment:start");
+  const end = createComment("vobs:fragment:end");
+  let parent = null;
+  let initialized = false;
+  const owner = getCurrentOwner();
+  const fragment = {
+    kind: "vobs-fragment",
+    start,
+    end,
+    mount(nextParent, anchor) {
+      if (parent && parent !== nextParent) {
+        throw new Error("Vobs Fragment: \u4E0D\u80FD\u8DE8\u7236\u8282\u70B9\u79FB\u52A8 Fragment");
+      }
+      if (initialized) {
+        moveRange(nextParent, start, end, anchor);
+        return;
+      }
+      const renderer = getRenderer();
+      renderer.insertBefore(nextParent, start, anchor);
+      renderer.insertBefore(nextParent, end, anchor);
+      parent = nextParent;
+      initialized = true;
+      if (owner) owner.run(() => factory(nextParent, end));
+      else factory(nextParent, end);
+    },
+    unmount(nextParent) {
+      if (!initialized || parent !== nextParent) {
+        throw new Error("Vobs Fragment: Fragment \u4E0D\u5C5E\u4E8E\u6307\u5B9A\u7236\u8282\u70B9");
+      }
+      const renderer = getRenderer();
+      let current = renderer.nextSibling(start);
+      while (current && current !== end) {
+        const next = renderer.nextSibling(current);
+        renderer.removeChild(nextParent, current);
+        current = next;
+      }
+      renderer.removeChild(nextParent, start);
+      renderer.removeChild(nextParent, end);
+      parent = null;
+      initialized = false;
+    }
+  };
+  return fragment;
+}
+__name(createFragment, "createFragment");
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+function moveRange(parent, start, end, anchor) {
+  const renderer = getRenderer();
+  const nodes = [start];
+  let current = renderer.nextSibling(start);
+  while (current) {
+    nodes.push(current);
+    if (current === end) break;
+    current = renderer.nextSibling(current);
+  }
+  if (nodes[nodes.length - 1] !== end) {
+    throw new Error("Vobs Fragment: \u627E\u4E0D\u5230\u7ED3\u675F\u951A\u70B9");
+  }
+  for (const node of nodes) renderer.insertBefore(parent, node, anchor);
+}
+__name(moveRange, "moveRange");
+
+// packages/runtime/src/dynamic.ts
+function insertDynamic(parent, anchor, factory) {
+  const marker = createComment("vobs:dynamic");
+  insertBefore(parent, marker, anchor);
+  let current = null;
+  effect(() => {
+    const next = createBlock(factory);
+    if (next === current) return;
+    if (current) removeChild(parent, current);
+    current = next;
+    if (current) insertBefore(parent, current, marker);
+  });
+}
+__name(insertDynamic, "insertDynamic");
+function insertList(parent, anchor, source, renderItem, keyOf) {
+  const marker = createComment("vobs:list");
+  insertBefore(parent, marker, anchor);
+  let entries = [];
+  const tracksIndex = renderItem.length >= 2;
+  effect(() => {
+    const items = source();
+    let keys = null;
+    if (keyOf) {
+      keys = new Array(items.length);
+      let allKeyed = items.length > 0;
+      for (let index = 0; index < items.length; index++) {
+        const key = keyOf(items[index], index);
+        if (key == null) {
+          allKeyed = false;
+          break;
+        }
+        keys[index] = key;
+      }
+      if (!allKeyed) keys = null;
+    }
+    const nextEntries = keys ? reconcileKeyed(items, keys, entries, renderItem) : reconcileIndexed(items, entries, renderItem);
+    const refreshed = tracksIndex ? /* @__PURE__ */ new Set() : null;
+    for (let index = 0; index < nextEntries.length; index++) {
+      const entry = nextEntries[index];
+      if (tracksIndex) {
+        if (entry.index !== index) {
+          refreshListEntry(parent, entry, index, renderItem);
+          refreshed.add(entry);
+        }
+      } else {
+        entry.index = index;
+      }
+    }
+    const retained = new Set(nextEntries);
+    for (const entry of entries) {
+      if (!retained.has(entry)) disposeEntry(parent, entry);
+    }
+    reorderListEntries(parent, marker, entries, nextEntries, refreshed);
+    entries = nextEntries;
+  });
+}
+__name(insertList, "insertList");
+function reorderListEntries(parent, marker, previous, nextEntries, forceInsert) {
+  const count = nextEntries.length;
+  if (count === 0) return;
+  if (previous.length === 0) {
+    let reference2 = marker;
+    for (let index = count - 1; index >= 0; index--) {
+      const node = nextEntries[index].node;
+      insertBefore(parent, node, reference2);
+      reference2 = node;
+    }
+    return;
+  }
+  const oldIndexOf = /* @__PURE__ */ new Map();
+  for (let index = 0; index < previous.length; index++) oldIndexOf.set(previous[index], index);
+  const seq = new Array(count);
+  for (let index = 0; index < count; index++) {
+    const entry = nextEntries[index];
+    seq[index] = forceInsert?.has(entry) ? -1 : oldIndexOf.get(entry) ?? -1;
+  }
+  const keep = computeKeptByLis(seq);
+  let reference = marker;
+  for (let index = count - 1; index >= 0; index--) {
+    const node = nextEntries[index].node;
+    if (keep[index]) {
+      reference = node;
+      continue;
+    }
+    insertBefore(parent, node, reference);
+    reference = node;
+  }
+}
+__name(reorderListEntries, "reorderListEntries");
+function computeKeptByLis(seq) {
+  const count = seq.length;
+  const keep = new Array(count).fill(false);
+  const tailsIndex = [];
+  const tailsValue = [];
+  const prev = new Array(count).fill(-1);
+  for (let i = 0; i < count; i++) {
+    const value = seq[i];
+    if (value < 0) continue;
+    let lo = 0;
+    let hi = tailsValue.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (tailsValue[mid] < value) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo === tailsValue.length) {
+      tailsValue.push(value);
+      tailsIndex.push(i);
+    } else {
+      tailsValue[lo] = value;
+      tailsIndex[lo] = i;
+    }
+    prev[i] = lo > 0 ? tailsIndex[lo - 1] : -1;
+  }
+  let cursor = tailsIndex.length > 0 ? tailsIndex[tailsIndex.length - 1] : -1;
+  while (cursor >= 0) {
+    keep[cursor] = true;
+    cursor = prev[cursor];
+  }
+  return keep;
+}
+__name(computeKeptByLis, "computeKeptByLis");
+function reconcileKeyed(items, keys, entries, renderItem) {
+  const previous = new Map(entries.map((entry) => [entry.key, entry]));
+  const seen = /* @__PURE__ */ new Set();
+  const nextEntries = [];
+  for (let index = 0; index < items.length; index++) {
+    const item = items[index];
+    const key = keys[index];
+    if (seen.has(key)) {
+      console.warn(`Vobs: \u68C0\u6D4B\u5230\u91CD\u590D\u7684\u5217\u8868 key: ${String(key)}`);
+    }
+    seen.add(key);
+    const entry = previous.get(key);
+    if (entry) {
+      previous.delete(key);
+      if (isPrimitiveItem(item) && !Object.is(entry.value, item)) {
+        nextEntries.push(createListEntry(item, index, key, renderItem));
+        continue;
+      }
+      entry.item.value = item;
+      entry.value = item;
+      nextEntries.push(entry);
+      continue;
+    }
+    nextEntries.push(createListEntry(item, index, key, renderItem));
+  }
+  return nextEntries;
+}
+__name(reconcileKeyed, "reconcileKeyed");
+function reconcileIndexed(items, entries, renderItem) {
+  const nextEntries = [];
+  for (let index = 0; index < items.length; index++) {
+    const item = items[index];
+    const entry = entries[index];
+    if (entry && isPrimitiveItem(item) && !Object.is(entry.value, item)) {
+      nextEntries.push(createListEntry(item, index, index, renderItem));
+      continue;
+    }
+    if (entry) {
+      entry.item.value = item;
+      entry.value = item;
+      nextEntries.push(entry);
+      continue;
+    }
+    nextEntries.push(createListEntry(item, index, index, renderItem));
+  }
+  return nextEntries;
+}
+__name(reconcileIndexed, "reconcileIndexed");
+function isPrimitiveItem(item) {
+  return item === null || typeof item !== "object";
+}
+__name(isPrimitiveItem, "isPrimitiveItem");
+function createListEntry(item, index, key, renderItem) {
+  const owner = createOwner();
+  let itemSignal;
+  let viewOwner;
+  let node;
+  owner.run(() => {
+    itemSignal = state(item);
+    viewOwner = createOwner();
+    node = viewOwner.run(() => renderItem(toReactiveItem(itemSignal, item), index));
+  });
+  associateNodeOwner(node, viewOwner);
+  return { key, node, owner, viewOwner, item: itemSignal, value: item, index };
+}
+__name(createListEntry, "createListEntry");
+function refreshListEntry(parent, entry, index, renderItem) {
+  removeChild(parent, entry.node);
+  entry.index = index;
+  const previousView = entry.viewOwner;
+  entry.owner.run(() => {
+    entry.viewOwner = createOwner();
+    entry.node = entry.viewOwner.run(() => renderItem(
+      toReactiveItem(entry.item, entry.value),
+      index
+    ));
+  });
+  previousView.dispose();
+  associateNodeOwner(entry.node, entry.viewOwner);
+}
+__name(refreshListEntry, "refreshListEntry");
+function toReactiveItem(item, initialValue) {
+  if (typeof initialValue !== "object" || initialValue === null) {
+    return initialValue;
+  }
+  return new Proxy(initialValue, {
+    get(_target, property, receiver) {
+      return Reflect.get(item.value, property, receiver);
+    },
+    has(_target, property) {
+      return property in item.value;
+    },
+    ownKeys() {
+      return Reflect.ownKeys(item.value);
+    },
+    getOwnPropertyDescriptor(_target, property) {
+      return Object.getOwnPropertyDescriptor(item.value, property);
+    }
+  });
+}
+__name(toReactiveItem, "toReactiveItem");
+function disposeEntry(parent, entry) {
+  removeChild(parent, entry.node);
+  entry.owner.dispose();
+}
+__name(disposeEntry, "disposeEntry");
+
+// packages/vobs/src/context.ts
+var ownerProviders = /* @__PURE__ */ new WeakMap();
+function inject(key, fallback) {
+  const owner = getCurrentOwner();
+  const value = owner ? injectFromOwner(owner, key) : void 0;
+  return value === void 0 ? fallback : value;
+}
+__name(inject, "inject");
+function injectFromOwner(owner, key) {
+  let current = owner;
+  while (current) {
+    const providers = ownerProviders.get(current);
+    if (providers?.has(key)) return providers.get(key);
+    current = current.parent;
+  }
+  return void 0;
+}
+__name(injectFromOwner, "injectFromOwner");
+
+// packages/vobs/src/app.ts
+function createInjectionKey(description) {
+  return Symbol(description);
+}
+__name(createInjectionKey, "createInjectionKey");
+
+// packages/ui/src/utils.ts
+function classNames(...values) {
+  return values.flatMap((value) => typeof value === "string" ? value.trim().split(/\s+/u) : []).filter(Boolean).join(" ");
+}
+__name(classNames, "classNames");
+function readProp(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  return value === void 0 ? fallback : value;
+}
+__name(readProp, "readProp");
+function hasProp(props, name) {
+  return name in props;
+}
+__name(hasProp, "hasProp");
+function bindClassList(root, props, readBaseClasses) {
+  effect(() => {
+    setAttribute(root, "class", classNames(
+      ...readBaseClasses(),
+      readString(props, "class"),
+      readString(props, "className")
+    ));
+  });
+}
+__name(bindClassList, "bindClassList");
+function bindCommonAttributes(root, props, skip = [], options = {}) {
+  const ignored = new Set(skip);
+  ignored.add("class");
+  ignored.add("className");
+  ignored.add("children");
+  ignored.add("style");
+  effect(() => {
+    const next = /* @__PURE__ */ new Map();
+    for (const name of Object.keys(props)) {
+      if (ignored.has(name) || name.startsWith("on")) continue;
+      if (!isCommonAttribute(name)) continue;
+      if (options.includeDataAria === false && (name.startsWith("aria-") || name.startsWith("data-"))) continue;
+      const value = Reflect.get(props, name);
+      const normalized = normalizeAttribute(name, value);
+      if (normalized !== void 0) next.set(normalized.name, normalized.value);
+    }
+    const managed = getManagedAttributes(root);
+    for (const name of managed) {
+      if (!next.has(name)) removeAttribute(root, name);
+    }
+    for (const [name, value] of next) setAttribute(root, name, value);
+    setManagedAttributes(root, next.keys());
+  });
+}
+__name(bindCommonAttributes, "bindCommonAttributes");
+function bindUserStyle(root, props) {
+  bindStyle(root, props, () => "");
+}
+__name(bindUserStyle, "bindUserStyle");
+function bindStyle(root, props, createStyle) {
+  effect(() => {
+    const userStyle = readString(props, "style");
+    const internalStyle = createStyle();
+    const style = [internalStyle, userStyle].filter(Boolean).join("; ");
+    if (style) setAttribute(root, "style", style);
+    else removeAttribute(root, "style");
+  });
+}
+__name(bindStyle, "bindStyle");
+function bindTextContent(node, read) {
+  effect(() => {
+    setTextContent(node, String(read() ?? ""));
+  });
+}
+__name(bindTextContent, "bindTextContent");
+function bindPropertyValue(node, name, read) {
+  effect(() => setProperty(node, name, read()));
+}
+__name(bindPropertyValue, "bindPropertyValue");
+function listen(root, event, props, propName, disabled) {
+  addEventListener(root, event, (reason) => {
+    if (disabled?.()) return;
+    const handler = Reflect.get(props, propName);
+    if (typeof handler === "function") handler(reason);
+  });
+}
+__name(listen, "listen");
+function mountSlot(parent, props, propName) {
+  insertDynamic(parent, null, () => resolveSlot(Reflect.get(props, propName)));
+}
+__name(mountSlot, "mountSlot");
+function resolveSlot(value) {
+  const resolved = typeof value === "function" ? value() : value;
+  if (resolved === void 0 || resolved === null || resolved === false) return null;
+  if (typeof resolved === "string" || typeof resolved === "number") return createText(String(resolved));
+  if (Array.isArray(resolved)) {
+    const children = resolved;
+    return createFragment((parent, anchor) => {
+      for (const child of children) {
+        const node = resolveSlot(child);
+        if (node) insertBefore(parent, node, anchor);
+      }
+    });
+  }
+  return resolved;
+}
+__name(resolveSlot, "resolveSlot");
+function setOptionalAttribute(node, name, value) {
+  if (value === void 0 || value === null || value === false || value === "") {
+    removeAttribute(node, name);
+    return;
+  }
+  setAttribute(node, name, String(value));
+}
+__name(setOptionalAttribute, "setOptionalAttribute");
+function setOptionalProperty(node, name, value) {
+  if (value === void 0 || value === null) return;
+  setProperty(node, name, value);
+}
+__name(setOptionalProperty, "setOptionalProperty");
+function readString(props, name) {
+  const value = Reflect.get(props, name);
+  return typeof value === "string" ? value : void 0;
+}
+__name(readString, "readString");
+function isCommonAttribute(name) {
+  return name === "id" || name === "title" || name === "role" || name === "tabIndex" || name.startsWith("aria-") || name.startsWith("data-");
+}
+__name(isCommonAttribute, "isCommonAttribute");
+function normalizeAttribute(name, value) {
+  if (value === void 0 || value === null) return void 0;
+  if (value === false && !name.startsWith("aria-") && !name.startsWith("data-")) return void 0;
+  return { name: name === "tabIndex" ? "tabindex" : name, value: String(value) };
+}
+__name(normalizeAttribute, "normalizeAttribute");
+var managedAttributes = /* @__PURE__ */ new WeakMap();
+function getManagedAttributes(node) {
+  return managedAttributes.get(node) ?? /* @__PURE__ */ new Set();
+}
+__name(getManagedAttributes, "getManagedAttributes");
+function setManagedAttributes(node, names) {
+  managedAttributes.set(node, new Set(names));
+}
+__name(setManagedAttributes, "setManagedAttributes");
+function removeAttribute(node, name) {
+  const candidate = node;
+  candidate.removeAttribute?.(name);
+}
+__name(removeAttribute, "removeAttribute");
+
+// packages/ui/src/button.ts
+function Button(props = {}) {
+  const root = createElement("button");
+  bindClassList(root, props, () => [
+    "vui-btn",
+    `vui-btn--${readProp(props, "variant", "primary")}`,
+    `vui-btn--${readProp(props, "size", "md")}`,
+    readProp(props, "iconOnly", false) ? "vui-btn--icon" : void 0
+  ]);
+  bindCommonAttributes(root, props, [
+    "variant",
+    "size",
+    "type",
+    "disabled",
+    "loading",
+    "iconOnly",
+    "icon",
+    "onClick"
+  ]);
+  effect(() => {
+    const disabled = readProp(props, "disabled", false) || readProp(props, "loading", false);
+    setOptionalProperty(root, "disabled", disabled);
+    setOptionalAttribute(root, "type", readProp(props, "type", "button"));
+    setOptionalAttribute(root, "aria-disabled", disabled ? "true" : void 0);
+    setOptionalAttribute(root, "aria-busy", readProp(props, "loading", false) ? "true" : void 0);
+  });
+  listen(root, "click", props, "onClick", () => readProp(props, "disabled", false) || readProp(props, "loading", false));
+  if (hasProp(props, "icon")) mountSlot(root, props, "icon");
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Button, "Button");
+function ButtonGroup(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-btn-group"]);
+  bindCommonAttributes(root, props);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(ButtonGroup, "ButtonGroup");
+
+// packages/ui/src/forms.ts
+function bindSignalProp(props) {
+  const value = readProp(props, "bind", void 0);
+  return value && typeof value === "object" && "value" in value ? value : void 0;
+}
+__name(bindSignalProp, "bindSignalProp");
+function Input(props = {}) {
+  const root = createElement("div");
+  const control = createElement("input");
+  bindClassList(root, props, () => [
+    "vui-input",
+    readProp(props, "type", "text") === "search" ? "vui-search" : void 0
+  ]);
+  bindUserStyle(root, props);
+  bindCommonAttributes(control, props, [
+    "type",
+    "name",
+    "value",
+    "placeholder",
+    "disabled",
+    "readOnly",
+    "required",
+    "icon",
+    "onInput",
+    "onChange",
+    "onBlur"
+  ]);
+  effect(() => {
+    setOptionalAttribute(control, "type", readProp(props, "type", "text"));
+    setOptionalAttribute(control, "name", readProp(props, "name", void 0));
+    setOptionalAttribute(control, "placeholder", readProp(props, "placeholder", void 0));
+    setOptionalProperty(control, "disabled", readProp(props, "disabled", false));
+    setOptionalProperty(control, "readOnly", readProp(props, "readOnly", false));
+    setOptionalProperty(control, "required", readProp(props, "required", false));
+  });
+  const bind = bindSignalProp(props);
+  if (bind) {
+    bindPropertyValue(control, "value", () => String(bind.value ?? ""));
+    listen(control, "input", { onInput: /* @__PURE__ */ __name((event) => {
+      bind.value = event.target.value;
+    }, "onInput") }, "onInput", () => readProp(props, "disabled", false));
+  } else if (hasProp(props, "value")) {
+    bindPropertyValue(control, "value", () => readProp(props, "value", void 0) ?? "");
+  }
+  if (hasProp(props, "icon")) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-input__icon");
+    mountSlot(icon, props, "icon");
+    insertBefore(root, icon, null);
+  }
+  insertBefore(root, control, null);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  listen(control, "input", props, "onInput", () => readProp(props, "disabled", false));
+  listen(control, "change", props, "onChange", () => readProp(props, "disabled", false));
+  listen(control, "blur", props, "onBlur", () => false);
+  return root;
+}
+__name(Input, "Input");
+function Textarea(props = {}) {
+  const root = createElement("textarea");
+  bindClassList(root, props, () => ["vui-textarea"]);
+  bindCommonAttributes(root, props, [
+    "value",
+    "placeholder",
+    "disabled",
+    "readOnly",
+    "required",
+    "rows",
+    "name",
+    "onInput",
+    "onChange",
+    "onBlur"
+  ]);
+  effect(() => {
+    setOptionalAttribute(root, "name", readProp(props, "name", void 0));
+    setOptionalAttribute(root, "placeholder", readProp(props, "placeholder", void 0));
+    setOptionalProperty(root, "disabled", readProp(props, "disabled", false));
+    setOptionalProperty(root, "readOnly", readProp(props, "readOnly", false));
+    setOptionalProperty(root, "required", readProp(props, "required", false));
+    setOptionalAttribute(root, "rows", readProp(props, "rows", void 0));
+  });
+  const bind = bindSignalProp(props);
+  if (bind) {
+    bindPropertyValue(root, "value", () => String(bind.value ?? ""));
+    listen(root, "input", { onInput: /* @__PURE__ */ __name((event) => {
+      bind.value = event.target.value;
+    }, "onInput") }, "onInput", () => readProp(props, "disabled", false));
+  } else if (hasProp(props, "value")) {
+    bindPropertyValue(root, "value", () => readProp(props, "value", void 0) ?? "");
+  }
+  listen(root, "input", props, "onInput", () => readProp(props, "disabled", false));
+  listen(root, "change", props, "onChange", () => readProp(props, "disabled", false));
+  listen(root, "blur", props, "onBlur", () => false);
+  return root;
+}
+__name(Textarea, "Textarea");
+function Select(props = {}) {
+  const root = createElement("select");
+  bindClassList(root, props, () => ["vui-select"]);
+  bindCommonAttributes(root, props, [
+    "name",
+    "value",
+    "disabled",
+    "required",
+    "multiple",
+    "size",
+    "onChange"
+  ]);
+  effect(() => {
+    setOptionalAttribute(root, "name", readProp(props, "name", void 0));
+    setOptionalProperty(root, "disabled", readProp(props, "disabled", false));
+    setOptionalProperty(root, "required", readProp(props, "required", false));
+    setOptionalProperty(root, "multiple", readProp(props, "multiple", false));
+    setOptionalAttribute(root, "size", readProp(props, "size", void 0));
+  });
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  const bind = bindSignalProp(props);
+  if (bind) {
+    bindPropertyValue(root, "value", () => String(bind.value ?? ""));
+    listen(root, "change", { onChange: /* @__PURE__ */ __name((event) => {
+      bind.value = event.target.value;
+    }, "onChange") }, "onChange", () => readProp(props, "disabled", false));
+  } else if (hasProp(props, "value")) {
+    bindPropertyValue(root, "value", () => readProp(props, "value", void 0) ?? "");
+  }
+  listen(root, "change", props, "onChange", () => readProp(props, "disabled", false));
+  return root;
+}
+__name(Select, "Select");
+function Checkbox(props = {}) {
+  return createChoice("checkbox", props);
+}
+__name(Checkbox, "Checkbox");
+function Radio(props = {}) {
+  return createChoice("radio", props);
+}
+__name(Radio, "Radio");
+function createChoice(type, props) {
+  const root = createElement("label");
+  const control = createElement("input");
+  const visual = createElement("span");
+  bindClassList(root, props, () => [`vui-${type}`]);
+  bindUserStyle(root, props);
+  bindCommonAttributes(control, props, [
+    "name",
+    "value",
+    "checked",
+    "disabled",
+    "required",
+    "onChange"
+  ]);
+  setAttribute(visual, "class", type === "checkbox" ? "vui-check__box" : "vui-radio__dot");
+  effect(() => {
+    setOptionalAttribute(control, "type", type);
+    setOptionalAttribute(control, "name", readProp(props, "name", void 0));
+    setOptionalAttribute(control, "value", readProp(props, "value", void 0));
+    setOptionalProperty(control, "disabled", readProp(props, "disabled", false));
+    setOptionalProperty(control, "required", readProp(props, "required", false));
+  });
+  const bind = bindSignalProp(props);
+  if (bind) {
+    bindPropertyValue(control, "checked", () => bind.value);
+    listen(control, "change", { onChange: /* @__PURE__ */ __name((event) => {
+      bind.value = event.target.checked;
+    }, "onChange") }, "onChange", () => readProp(props, "disabled", false));
+  } else if (hasProp(props, "checked")) {
+    bindPropertyValue(control, "checked", () => readProp(props, "checked", false));
+  }
+  insertBefore(root, control, null);
+  insertBefore(root, visual, null);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  listen(control, "change", props, "onChange", () => readProp(props, "disabled", false));
+  return root;
+}
+__name(createChoice, "createChoice");
+function Switch(props = {}) {
+  const root = createElement("label");
+  const control = createElement("input");
+  const thumb = createElement("span");
+  bindClassList(root, props, () => [
+    "vui-switch",
+    readProp(props, "size", "md") === "sm" ? "vui-switch--sm" : void 0
+  ]);
+  bindUserStyle(root, props);
+  bindCommonAttributes(root, props, ["role"]);
+  bindCommonAttributes(control, props, [
+    "checked",
+    "disabled",
+    "readOnly",
+    "name",
+    "value",
+    "onChange"
+  ]);
+  setAttribute(thumb, "class", "vui-switch__thumb");
+  setAttribute(root, "role", "switch");
+  const bind = bindSignalProp(props);
+  effect(() => {
+    setOptionalAttribute(control, "type", "checkbox");
+    setOptionalAttribute(control, "name", readProp(props, "name", void 0));
+    setOptionalAttribute(control, "value", readProp(props, "value", void 0));
+    setOptionalProperty(control, "disabled", readProp(props, "disabled", false));
+    setOptionalProperty(control, "readOnly", readProp(props, "readOnly", false));
+    setOptionalAttribute(root, "aria-checked", (bind ? bind.value : readProp(props, "checked", false)) ? "true" : "false");
+    setOptionalAttribute(root, "aria-disabled", readProp(props, "disabled", false) ? "true" : void 0);
+  });
+  if (bind) {
+    bindPropertyValue(control, "checked", () => bind.value);
+    listen(control, "change", { onChange: /* @__PURE__ */ __name((event) => {
+      bind.value = event.target.checked;
+    }, "onChange") }, "onChange", () => readProp(props, "disabled", false));
+  } else if (hasProp(props, "checked")) {
+    bindPropertyValue(control, "checked", () => readProp(props, "checked", false));
+  }
+  insertBefore(root, control, null);
+  insertBefore(root, thumb, null);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  listen(control, "change", props, "onChange", () => readProp(props, "disabled", false));
+  return root;
+}
+__name(Switch, "Switch");
+
+// packages/ui/src/card.ts
+function Card(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-card"]);
+  bindCommonAttributes(root, props, ["title", "description"]);
+  bindUserStyle(root, props);
+  if (hasProp(props, "title")) {
+    const title = createElement("div");
+    const text = createText("");
+    setAttribute(title, "class", "vui-card__title");
+    bindTextContent(text, () => readProp(props, "title", ""));
+    insertBefore(title, text, null);
+    insertBefore(root, title, null);
+  }
+  if (hasProp(props, "description")) {
+    const description = createElement("p");
+    const text = createText("");
+    setAttribute(description, "class", "vui-card__desc");
+    bindTextContent(text, () => readProp(props, "description", ""));
+    insertBefore(description, text, null);
+    insertBefore(root, description, null);
+  }
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Card, "Card");
+function CardHeader(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-card__header"]);
+  bindCommonAttributes(root, props);
+  bindUserStyle(root, props);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(CardHeader, "CardHeader");
+
+// packages/ui/src/tag.ts
+function Tag(props = {}) {
+  const root = createElement("span");
+  bindClassList(root, props, () => [
+    "vui-tag",
+    readProp(props, "tone", "default") === "default" ? void 0 : `vui-tag--${readProp(props, "tone", "default")}`
+  ]);
+  bindCommonAttributes(root, props, ["tone"]);
+  bindUserStyle(root, props);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Tag, "Tag");
+
+// packages/ui/src/alert.ts
+function Alert(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => [
+    "vui-alert",
+    `vui-alert--${readProp(props, "tone", "info")}`
+  ]);
+  bindCommonAttributes(root, props, ["tone", "title", "description", "icon", "role"]);
+  bindUserStyle(root, props);
+  setAttribute(root, "role", "alert");
+  if (hasProp(props, "icon")) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-alert__icon");
+    mountSlot(icon, props, "icon");
+    insertBefore(root, icon, null);
+  }
+  const content = createElement("div");
+  if (hasProp(props, "title")) {
+    const title = createElement("div");
+    const text = createText("");
+    setAttribute(title, "class", "vui-alert__title");
+    bindTextContent(text, () => readProp(props, "title", ""));
+    insertBefore(title, text, null);
+    insertBefore(content, title, null);
+  }
+  if (hasProp(props, "description")) {
+    const description = createElement("div");
+    const text = createText("");
+    setAttribute(description, "class", "vui-alert__desc");
+    bindTextContent(text, () => readProp(props, "description", ""));
+    insertBefore(description, text, null);
+    insertBefore(content, description, null);
+  }
+  if (hasProp(props, "children")) mountSlot(content, props, "children");
+  insertBefore(root, content, null);
+  return root;
+}
+__name(Alert, "Alert");
+
+// packages/ui/src/tabs.ts
+function Tabs(props) {
+  const root = createElement("div");
+  const tablist = createElement("div");
+  const panel = createElement("div");
+  const internalValue = state(void 0);
+  bindClassList(root, props, () => ["vui-tabs-root"]);
+  bindCommonAttributes(root, props, ["items", "value", "variant", "onChange"]);
+  setAttribute(tablist, "role", "tablist");
+  effect(() => {
+    const variant = readProp(props, "variant", "default");
+    setAttribute(tablist, "class", `vui-tabs${variant === "filled" ? " vui-tabs--filled" : ""}`);
+  });
+  setAttribute(panel, "class", "vui-tabs__panel");
+  insertDynamic(tablist, null, () => createTabButtons(props, internalValue));
+  insertDynamic(panel, null, () => {
+    const item = activeItem(readProp(props, "items", []), activeId(props, internalValue));
+    return item?.content === void 0 ? null : resolveSlot(item.content);
+  });
+  insertBefore(root, tablist, null);
+  insertBefore(root, panel, null);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Tabs, "Tabs");
+function createTabButtons(props, internalValue) {
+  const items = readProp(props, "items", []);
+  const selected = activeId(props, internalValue);
+  return createFragment((parent, anchor) => {
+    for (const item of items) {
+      const button = createElement("button");
+      const isActive = item.id === selected;
+      setAttribute(button, "class", `vui-tab${isActive ? " is-active" : ""}`);
+      setAttribute(button, "role", "tab");
+      setAttribute(button, "type", "button");
+      setAttribute(button, "aria-selected", isActive ? "true" : "false");
+      setAttribute(button, "data-tab-id", item.id);
+      if (item.disabled === true) {
+        setAttribute(button, "aria-disabled", "true");
+        setProperty(button, "disabled", true);
+      }
+      insertBefore(button, createText(item.label), null);
+      addEventListener(button, "click", () => {
+        if (item.disabled === true) return;
+        if (readProp(props, "value", void 0) === void 0) internalValue.value = item.id;
+        const onChange = readProp(props, "onChange", void 0);
+        if (typeof onChange === "function") onChange(item.id);
+      });
+      insertBefore(parent, button, anchor);
+    }
+  });
+}
+__name(createTabButtons, "createTabButtons");
+function activeId(props, internalValue) {
+  const controlled = readProp(props, "value", void 0);
+  if (controlled !== void 0) return controlled;
+  if (internalValue.value !== void 0) return internalValue.value;
+  return readProp(props, "items", []).find((item) => item.disabled !== true)?.id;
+}
+__name(activeId, "activeId");
+function activeItem(items, id) {
+  return items.find((item) => item.id === id);
+}
+__name(activeItem, "activeItem");
+
+// packages/ui/src/overlay.ts
+function createPortal(node, adapter, target) {
+  const placeholder = createComment("vui:portal");
+  const owner = getCurrentOwner();
+  if (!owner) throw new Error("Vobs UI: createPortal \u5FC5\u987B\u5728\u7EC4\u4EF6 Owner \u4F5C\u7528\u57DF\u5185\u8C03\u7528");
+  adapter.mount(node, target);
+  const cleanup = /* @__PURE__ */ __name(() => adapter.unmount(node, target), "cleanup");
+  owner.onDispose(cleanup);
+  return placeholder;
+}
+__name(createPortal, "createPortal");
+function createDOMPortalAdapter() {
+  return {
+    mount(node, target) {
+      insertBefore(target, node, null);
+    },
+    unmount(node, target) {
+      removePortalNode(node, target);
+    }
+  };
+}
+__name(createDOMPortalAdapter, "createDOMPortalAdapter");
+function createFocusTrap(root, options = {}) {
+  let isActive = false;
+  let disposed = false;
+  let previouslyFocused = null;
+  const focusable = /* @__PURE__ */ __name(() => [...root.querySelectorAll(FOCUSABLE_SELECTOR)].filter((element) => !element.hasAttribute("disabled") && element.getAttribute("aria-hidden") !== "true"), "focusable");
+  const onKeyDown = /* @__PURE__ */ __name((event) => {
+    if (!isActive || disposed) return;
+    if (event.key === "Escape") {
+      options.onEscape?.(event);
+      return;
+    }
+    if (event.key !== "Tab") return;
+    const elements = focusable();
+    if (elements.length === 0) {
+      event.preventDefault();
+      root.focus();
+      return;
+    }
+    const first = elements[0];
+    const last = elements[elements.length - 1];
+    const current = document.activeElement;
+    if (event.shiftKey && current === first) {
+      event.preventDefault();
+      last.focus();
+    } else if (!event.shiftKey && current === last) {
+      event.preventDefault();
+      first.focus();
+    }
+  }, "onKeyDown");
+  const activate = /* @__PURE__ */ __name(() => {
+    if (disposed || isActive) return;
+    isActive = true;
+    previouslyFocused = document.activeElement;
+    root.addEventListener("keydown", onKeyDown);
+    const initial = resolveInitialFocus(options.initialFocus) ?? focusable()[0] ?? root;
+    if (!root.hasAttribute("tabindex") && initial === root) root.setAttribute("tabindex", "-1");
+    initial.focus();
+  }, "activate");
+  const deactivate = /* @__PURE__ */ __name(() => {
+    if (!isActive) return;
+    isActive = false;
+    root.removeEventListener("keydown", onKeyDown);
+    if (options.restoreFocus !== false && typeof HTMLElement !== "undefined" && previouslyFocused instanceof HTMLElement) previouslyFocused.focus();
+    previouslyFocused = null;
+  }, "deactivate");
+  const handle = {
+    get active() {
+      return isActive;
+    },
+    activate,
+    deactivate,
+    dispose() {
+      if (disposed) return;
+      deactivate();
+      disposed = true;
+    }
+  };
+  if (getCurrentOwner()) onDispose(() => handle.dispose());
+  return handle;
+}
+__name(createFocusTrap, "createFocusTrap");
+function createOverlayManager() {
+  let entries = [];
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = /* @__PURE__ */ __name(() => {
+    const snapshot = entries.slice();
+    for (const listener of listeners) listener(snapshot);
+  }, "notify");
+  return {
+    get entries() {
+      return entries;
+    },
+    open(entry) {
+      entries = [...entries.filter((current) => current.id !== entry.id), entry];
+      notify();
+    },
+    close(id) {
+      const next = entries.filter((entry) => entry.id !== id);
+      if (next.length === entries.length) return;
+      entries = next;
+      notify();
+    },
+    bringToFront(id) {
+      const entry = entries.find((current) => current.id === id);
+      if (!entry || entries[entries.length - 1] === entry) return;
+      entries = [...entries.filter((current) => current !== entry), entry];
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(entries.slice());
+      return () => listeners.delete(listener);
+    }
+  };
+}
+__name(createOverlayManager, "createOverlayManager");
+function resolveInitialFocus(target) {
+  if (!target) return null;
+  return typeof target === "function" ? target() : target;
+}
+__name(resolveInitialFocus, "resolveInitialFocus");
+function removePortalNode(node, target) {
+  if (isVobsFragment(node)) {
+    let current = node.start.nextSibling;
+    while (current && current !== node.end) {
+      const next = current.nextSibling;
+      target.removeChild(current);
+      current = next;
+    }
+    if (node.start.parentNode === target) target.removeChild(node.start);
+    if (node.end.parentNode === target) target.removeChild(node.end);
+    return;
+  }
+  if (node.parentNode === target) target.removeChild(node);
+}
+__name(removePortalNode, "removePortalNode");
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "area[href]",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "iframe",
+  "object",
+  "embed",
+  "[contenteditable]",
+  "[tabindex]"
+].join(",");
+
+// packages/ui/src/dialog.ts
+function Dialog(props = {}) {
+  const root = createElement("div");
+  const surface = createElement("section");
+  const body = createElement("div");
+  bindClassList(root, props, () => ["vui-backdrop"]);
+  bindUserStyle(root, props);
+  bindCommonAttributes(surface, props, [
+    "open",
+    "title",
+    "headerActions",
+    "size",
+    "modal",
+    "closeOnBackdrop",
+    "closeOnEscape",
+    "titleId",
+    "descriptionId",
+    "closeLabel",
+    "onClose",
+    "portal",
+    "portalTarget"
+  ]);
+  setAttribute(root, "role", "presentation");
+  setAttribute(surface, "class", "vui-dialog");
+  setAttribute(surface, "role", "dialog");
+  setAttribute(body, "class", "vui-dialog__body");
+  effect(() => {
+    const open = readProp(props, "open", false);
+    const modal = readProp(props, "modal", true);
+    setOptionalProperty(root, "hidden", !open);
+    setOptionalAttribute(root, "data-state", open ? "open" : "closed");
+    setOptionalAttribute(surface, "aria-modal", modal ? "true" : "false");
+    setOptionalAttribute(surface, "aria-labelledby", readProp(props, "titleId", void 0));
+    setOptionalAttribute(surface, "aria-describedby", readProp(props, "descriptionId", void 0));
+    setOptionalAttribute(surface, "data-size", readProp(props, "size", "md"));
+  });
+  if (hasProp(props, "title") || hasProp(props, "headerActions") || hasProp(props, "onClose")) {
+    const head = createElement("header");
+    setAttribute(head, "class", "vui-dialog__head");
+    if (hasProp(props, "title")) {
+      const title = createElement("div");
+      const text = createText("");
+      setAttribute(title, "class", "vui-dialog__title");
+      bindTextContent(text, () => readProp(props, "title", ""));
+      insertBefore(title, text, null);
+      insertBefore(head, title, null);
+    }
+    if (hasProp(props, "headerActions")) mountSlot(head, props, "headerActions");
+    if (hasProp(props, "onClose")) {
+      const close = createElement("button");
+      setAttribute(close, "class", "vui-dialog__close");
+      setAttribute(close, "type", "button");
+      setAttribute(close, "aria-label", readProp(props, "closeLabel", "Close"));
+      insertBefore(close, createText("x"), null);
+      addEventListener(close, "click", () => emitClose(props, "close-button"));
+      insertBefore(head, close, null);
+    }
+    insertBefore(surface, head, null);
+  }
+  if (hasProp(props, "children")) mountSlot(body, props, "children");
+  insertBefore(surface, body, null);
+  insertBefore(root, surface, null);
+  addEventListener(root, "click", (event) => {
+    if (event.target !== root) return;
+    if (readProp(props, "closeOnBackdrop", true)) emitClose(props, "backdrop");
+  });
+  addEventListener(root, "keydown", (event) => {
+    if (event.key !== "Escape") return;
+    if (readProp(props, "closeOnEscape", true)) emitClose(props, "escape");
+  });
+  const portal = readProp(props, "portal", void 0);
+  return portal ? createPortal(root, portal, readProp(props, "portalTarget", void 0)) : root;
+}
+__name(Dialog, "Dialog");
+function emitClose(props, reason) {
+  if (!readProp(props, "open", false)) return;
+  const handler = readProp(props, "onClose", void 0);
+  if (typeof handler === "function") handler(reason);
+}
+__name(emitClose, "emitClose");
+
+// packages/ui/src/menu.ts
+function Menu(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-menu"]);
+  bindCommonAttributes(root, props, ["items", "onSelect"]);
+  if (!hasProp(props, "role")) setAttribute(root, "role", "menu");
+  if (hasProp(props, "items")) {
+    insertDynamic(root, null, () => createMenuItems(props));
+  }
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Menu, "Menu");
+function MenuDivider(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-menu__divider"]);
+  bindCommonAttributes(root, props);
+  setAttribute(root, "role", "separator");
+  return root;
+}
+__name(MenuDivider, "MenuDivider");
+function createMenuItems(props) {
+  const items = readProp(props, "items", []);
+  return createFragment((parent, anchor) => {
+    for (const item of items) {
+      const node = item.divider === true ? createMenuDividerNode(item) : createMenuItemNode(item, props);
+      insertBefore(parent, node, anchor);
+    }
+  });
+}
+__name(createMenuItems, "createMenuItems");
+function createMenuDividerNode(item) {
+  const divider = createElement("div");
+  setAttribute(divider, "class", "vui-menu__divider");
+  setAttribute(divider, "role", "separator");
+  setOptionalAttribute(divider, "data-menu-item-id", item.id);
+  return divider;
+}
+__name(createMenuDividerNode, "createMenuDividerNode");
+function createMenuItemNode(item, props) {
+  const button = createElement("button");
+  setAttribute(button, "class", `vui-menu__item${item.danger === true ? " vui-menu__item--danger" : ""}`);
+  setAttribute(button, "type", "button");
+  setAttribute(button, "role", "menuitem");
+  setOptionalAttribute(button, "data-menu-item-id", item.id);
+  if (item.disabled === true) {
+    setProperty(button, "disabled", true);
+    setAttribute(button, "aria-disabled", "true");
+  }
+  if (item.icon !== void 0) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-menu__icon");
+    mountSlot(icon, item, "icon");
+    insertBefore(button, icon, null);
+  }
+  if (item.label !== void 0) {
+    const label = createElement("span");
+    setAttribute(label, "class", "vui-menu__label");
+    insertBefore(label, createText(item.label), null);
+    insertBefore(button, label, null);
+  } else if (item.content !== void 0) {
+    mountSlot(button, item, "content");
+  }
+  if (item.shortcut !== void 0) {
+    const shortcut = createElement("span");
+    setAttribute(shortcut, "class", "vui-menu__shortcut");
+    insertBefore(shortcut, createText(item.shortcut), null);
+    insertBefore(button, shortcut, null);
+  }
+  addEventListener(button, "click", (event) => {
+    if (item.disabled === true || item.id === void 0) return;
+    const handler = readProp(props, "onSelect", void 0);
+    if (typeof handler === "function") handler(item.id, event);
+  });
+  return button;
+}
+__name(createMenuItemNode, "createMenuItemNode");
+
+// packages/ui/src/nav-list.ts
+function NavList(props = {}) {
+  const root = createElement("nav");
+  const internalValue = state(void 0);
+  bindClassList(root, props, () => ["vui-navlist"]);
+  bindCommonAttributes(root, props, ["groups", "value", "defaultValue", "onChange"]);
+  insertDynamic(root, null, () => createNavGroups(props, internalValue));
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(NavList, "NavList");
+function createNavGroups(props, internalValue) {
+  const groups = readProp(props, "groups", []);
+  const selected = activeId2(props, groups, internalValue);
+  return createFragment((parent, anchor) => {
+    for (const group of groups) {
+      const groupRoot = createElement("div");
+      setAttribute(groupRoot, "class", "vui-navlist__group");
+      setOptionalAttribute(groupRoot, "data-nav-group-id", group.id);
+      if (group.title !== void 0) {
+        const title = createElement("div");
+        setAttribute(title, "class", "vui-navlist__group-title");
+        insertBefore(title, createText(group.title), null);
+        insertBefore(groupRoot, title, null);
+      }
+      for (const item of group.items) {
+        insertBefore(groupRoot, createNavItem(item, props, selected, internalValue), null);
+      }
+      insertBefore(parent, groupRoot, anchor);
+    }
+  });
+}
+__name(createNavGroups, "createNavGroups");
+function createNavItem(item, props, selected, internalValue) {
+  const active = item.id === selected;
+  const element = createElement(item.href === void 0 ? "button" : "a");
+  setAttribute(element, "class", `vui-navlist__item${active ? " is-active" : ""}`);
+  if (item.href !== void 0) setAttribute(element, "role", "link");
+  setOptionalAttribute(element, "data-nav-id", item.id);
+  if (item.href !== void 0) {
+    setAttribute(element, "href", item.href);
+    setOptionalAttribute(element, "target", item.target);
+    setOptionalAttribute(element, "rel", item.rel);
+  } else {
+    setAttribute(element, "type", "button");
+  }
+  if (active) setAttribute(element, "aria-current", "page");
+  if (item.disabled === true) {
+    setAttribute(element, "aria-disabled", "true");
+    setProperty(element, "tabIndex", -1);
+    if (item.href === void 0) setProperty(element, "disabled", true);
+  }
+  if (item.icon !== void 0) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-navlist__icon");
+    mountSlot(icon, item, "icon");
+    insertBefore(element, icon, null);
+  }
+  const label = createElement("span");
+  setAttribute(label, "class", "vui-navlist__label");
+  insertBefore(label, createText(item.label), null);
+  insertBefore(element, label, null);
+  if (item.badge !== void 0) {
+    const badge = createElement("span");
+    setAttribute(badge, "class", "vui-navlist__badge");
+    mountSlot(badge, item, "badge");
+    insertBefore(element, badge, null);
+  }
+  addEventListener(element, "click", (event) => {
+    if (item.disabled === true) {
+      event.preventDefault?.();
+      return;
+    }
+    if (readProp(props, "value", void 0) === void 0) internalValue.value = item.id;
+    const handler = readProp(props, "onChange", void 0);
+    if (typeof handler === "function") handler(item.id, event);
+  });
+  return element;
+}
+__name(createNavItem, "createNavItem");
+function activeId2(props, groups, internalValue) {
+  const controlled = readProp(props, "value", void 0);
+  if (controlled !== void 0) return controlled;
+  if (internalValue.value !== void 0) return internalValue.value;
+  const defaultValue = readProp(props, "defaultValue", void 0);
+  if (defaultValue !== void 0) return defaultValue;
+  for (const group of groups) {
+    const active = group.items.find((item) => item.active === true);
+    if (active) return active.id;
+  }
+  return void 0;
+}
+__name(activeId2, "activeId");
+
+// packages/ui/src/pagination.ts
+function Pagination(props = {}) {
+  const root = createElement("nav");
+  bindClassList(root, props, () => ["vui-pagination"]);
+  bindCommonAttributes(root, props, [
+    "page",
+    "pageCount",
+    "siblingCount",
+    "disabled",
+    "previousLabel",
+    "nextLabel",
+    "previousIcon",
+    "nextIcon",
+    "onChange"
+  ]);
+  if (!hasProp(props, "aria-label")) setAttribute(root, "aria-label", "Pagination");
+  insertDynamic(root, null, () => createPaginationItems(props));
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Pagination, "Pagination");
+function createPaginationItems(props) {
+  const pageCount = Math.max(0, Math.floor(readProp(props, "pageCount", 0)));
+  const page = clampPage(readProp(props, "page", 1), pageCount);
+  const siblingCount = Math.max(0, Math.floor(readProp(props, "siblingCount", 1)));
+  const disabled = readProp(props, "disabled", false);
+  const items = pageCount === 0 ? [] : buildPaginationItems(page, pageCount, siblingCount);
+  return createFragment((parent, anchor) => {
+    insertBefore(parent, createPaginationControl(props, "previous", page <= 1 || disabled), anchor);
+    for (const item of items) {
+      if (typeof item === "number") {
+        insertBefore(parent, createPageButton(item, item === page, disabled, props), anchor);
+      } else {
+        insertBefore(parent, createEllipsis(item), anchor);
+      }
+    }
+    insertBefore(parent, createPaginationControl(props, "next", page >= pageCount || pageCount === 0 || disabled), anchor);
+  });
+}
+__name(createPaginationItems, "createPaginationItems");
+function createPaginationControl(props, direction, disabled) {
+  const button = createElement("button");
+  setAttribute(button, "class", "vui-pagination__item");
+  setAttribute(button, "type", "button");
+  setProperty(button, "disabled", disabled);
+  setOptionalAttribute(button, "aria-label", direction === "previous" ? readProp(props, "previousLabel", "Previous") : readProp(props, "nextLabel", "Next"));
+  if (disabled) setAttribute(button, "aria-disabled", "true");
+  const icon = direction === "previous" ? readProp(props, "previousIcon", void 0) : readProp(props, "nextIcon", void 0);
+  const fallback = direction === "previous" ? "<" : ">";
+  const node = icon === void 0 ? createText(fallback) : resolveSlot(icon);
+  if (node) insertBefore(button, node, null);
+  addEventListener(button, "click", () => {
+    if (disabled) return;
+    const current = readProp(props, "page", 1);
+    const nextPage = direction === "previous" ? current - 1 : current + 1;
+    emitPageChange(props, clampPage(nextPage, readProp(props, "pageCount", 0)));
+  });
+  return button;
+}
+__name(createPaginationControl, "createPaginationControl");
+function createPageButton(page, active, disabled, props) {
+  const button = createElement("button");
+  setAttribute(button, "class", `vui-pagination__item${active ? " is-active" : ""}`);
+  setAttribute(button, "type", "button");
+  setProperty(button, "disabled", disabled);
+  setAttribute(button, "aria-label", `Page ${page}`);
+  if (active) setAttribute(button, "aria-current", "page");
+  if (disabled) setAttribute(button, "aria-disabled", "true");
+  insertBefore(button, createText(String(page)), null);
+  addEventListener(button, "click", () => {
+    if (!disabled) emitPageChange(props, page);
+  });
+  return button;
+}
+__name(createPageButton, "createPageButton");
+function createEllipsis(item) {
+  const button = createElement("button");
+  setAttribute(button, "class", "vui-pagination__item");
+  setAttribute(button, "type", "button");
+  setProperty(button, "disabled", true);
+  setAttribute(button, "aria-label", item === "ellipsis-left" ? "Previous pages" : "Next pages");
+  setAttribute(button, "aria-hidden", "true");
+  insertBefore(button, createText("..."), null);
+  return button;
+}
+__name(createEllipsis, "createEllipsis");
+function emitPageChange(props, page) {
+  const handler = readProp(props, "onChange", void 0);
+  if (typeof handler === "function") handler(page);
+}
+__name(emitPageChange, "emitPageChange");
+function clampPage(page, pageCount) {
+  if (pageCount <= 0) return 1;
+  return Math.min(pageCount, Math.max(1, Math.floor(Number.isFinite(page) ? page : 1)));
+}
+__name(clampPage, "clampPage");
+function buildPaginationItems(page, pageCount, siblingCount) {
+  const totalVisible = siblingCount * 2 + 5;
+  if (pageCount <= totalVisible) {
+    return Array.from({ length: pageCount }, (_, index) => index + 1);
+  }
+  const left = Math.max(page - siblingCount, 2);
+  const right = Math.min(page + siblingCount, pageCount - 1);
+  const items = [1];
+  if (left > 2) items.push("ellipsis-left");
+  for (let value = left; value <= right; value++) items.push(value);
+  if (right < pageCount - 1) items.push("ellipsis-right");
+  items.push(pageCount);
+  return items;
+}
+__name(buildPaginationItems, "buildPaginationItems");
+
+// packages/ui/src/avatar.ts
+function Avatar(props = {}) {
+  const root = createElement("span");
+  bindClassList(root, props, () => [
+    "vui-avatar",
+    readProp(props, "size", "md") === "sm" ? "vui-avatar--sm" : void 0,
+    readProp(props, "size", "md") === "lg" ? "vui-avatar--lg" : void 0,
+    readProp(props, "shape", "circle") === "square" ? "vui-avatar--square" : void 0,
+    readProp(props, "accent", false) ? "vui-avatar--accent" : void 0
+  ]);
+  bindCommonAttributes(root, props, ["src", "alt", "size", "shape", "accent", "fallback"]);
+  bindUserStyle(root, props);
+  insertDynamic(root, null, () => createAvatarContent(props));
+  return root;
+}
+__name(Avatar, "Avatar");
+function createAvatarContent(props) {
+  const src = readProp(props, "src", void 0);
+  if (src) {
+    const image = createElement("img");
+    setAttribute(image, "class", "vui-avatar__image");
+    setAttribute(image, "src", src);
+    setAttribute(image, "alt", readProp(props, "alt", ""));
+    return image;
+  }
+  if (hasProp(props, "fallback")) {
+    const fallback = resolveSlot(Reflect.get(props, "fallback"));
+    if (fallback) return fallback;
+  }
+  if (hasProp(props, "children")) {
+    const children = resolveSlot(Reflect.get(props, "children"));
+    if (children) return children;
+  }
+  return createText("");
+}
+__name(createAvatarContent, "createAvatarContent");
+
+// packages/ui/src/page-header.ts
+function PageHeader(props = {}) {
+  const root = createElement("header");
+  const main = createElement("div");
+  bindClassList(root, props, () => ["vui-pagehead"]);
+  bindCommonAttributes(root, props, ["title", "subtitle", "actions"]);
+  bindUserStyle(root, props);
+  setAttribute(main, "class", "vui-pagehead__main");
+  if (hasProp(props, "title")) {
+    const title = createElement("h1");
+    const text = createText("");
+    setAttribute(title, "class", "vui-pagehead__title");
+    bindTextContent(text, () => readProp(props, "title", ""));
+    insertBefore(title, text, null);
+    insertBefore(main, title, null);
+  }
+  if (hasProp(props, "subtitle")) {
+    const subtitle = createElement("p");
+    const text = createText("");
+    setAttribute(subtitle, "class", "vui-pagehead__subtitle");
+    bindTextContent(text, () => readProp(props, "subtitle", ""));
+    insertBefore(subtitle, text, null);
+    insertBefore(main, subtitle, null);
+  }
+  if (hasProp(props, "children")) mountSlot(main, props, "children");
+  insertBefore(root, main, null);
+  if (hasProp(props, "actions")) {
+    const actions = createElement("div");
+    setAttribute(actions, "class", "vui-pagehead__actions");
+    mountSlot(actions, props, "actions");
+    insertBefore(root, actions, null);
+  }
+  return root;
+}
+__name(PageHeader, "PageHeader");
+function PageHeaderAction(props = {}) {
+  const root = createElement(props.href === void 0 ? "button" : "a");
+  bindClassList(root, props, () => [
+    "vui-pagehead__btn",
+    readProp(props, "primary", false) ? "is-primary" : void 0
+  ]);
+  bindCommonAttributes(root, props, ["href", "primary", "disabled", "onClick"]);
+  if (props.href === void 0) setAttribute(root, "type", "button");
+  else setAttribute(root, "href", props.href);
+  effect(() => {
+    const disabled = readProp(props, "disabled", false);
+    setOptionalAttribute(root, "aria-disabled", disabled ? "true" : void 0);
+    if (props.href === void 0) setProperty(root, "disabled", disabled);
+  });
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  addEventListener(root, "click", (event) => {
+    if (readProp(props, "disabled", false)) {
+      event.preventDefault?.();
+      return;
+    }
+    const handler = readProp(props, "onClick", void 0);
+    if (typeof handler === "function") handler(event);
+  });
+  return root;
+}
+__name(PageHeaderAction, "PageHeaderAction");
+
+// packages/ui/src/table.ts
+function Table(props = {}) {
+  const root = createElement("table");
+  const head = createElement("thead");
+  const body = createElement("tbody");
+  bindClassList(root, props, () => ["vui-table"]);
+  bindCommonAttributes(root, props, ["columns", "rows", "caption", "empty", "rowKey", "onRowClick"]);
+  bindUserStyle(root, props);
+  if (hasProp(props, "caption")) {
+    const caption = createElement("caption");
+    const text = createText("");
+    bindTextContent(text, () => readProp(props, "caption", ""));
+    insertBefore(caption, text, null);
+    insertBefore(root, caption, null);
+  }
+  insertDynamic(head, null, () => createTableHead(props));
+  insertDynamic(body, null, () => createTableBody(props));
+  insertBefore(root, head, null);
+  insertBefore(root, body, null);
+  return root;
+}
+__name(Table, "Table");
+function TablePanel(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-tablepanel"]);
+  bindCommonAttributes(root, props, ["columns", "rows", "empty", "footer", "rowKey", "onRowClick"]);
+  bindUserStyle(root, props);
+  const table = Table({
+    get columns() {
+      return readProp(props, "columns", []);
+    },
+    get rows() {
+      return readProp(props, "rows", []);
+    },
+    get empty() {
+      return readProp(props, "empty", void 0);
+    },
+    get rowKey() {
+      return readProp(props, "rowKey", void 0);
+    },
+    get onRowClick() {
+      return readProp(props, "onRowClick", void 0);
+    }
+  });
+  insertBefore(root, table, null);
+  if (hasProp(props, "footer")) {
+    const footer = createElement("div");
+    setAttribute(footer, "class", "vui-tablepanel__foot");
+    mountSlot(footer, props, "footer");
+    insertBefore(root, footer, null);
+  }
+  return root;
+}
+__name(TablePanel, "TablePanel");
+function createTableHead(props) {
+  const columns = readProp(props, "columns", []);
+  return createFragment((parent, anchor) => {
+    const row = createElement("tr");
+    for (const column of columns) {
+      const cell = createElement("th");
+      setAttribute(cell, "scope", "col");
+      setAttribute(cell, "data-column-id", column.id);
+      applyAlignment(cell, column.align);
+      insertBefore(cell, createText(column.label), null);
+      insertBefore(row, cell, null);
+    }
+    insertBefore(parent, row, anchor);
+  });
+}
+__name(createTableHead, "createTableHead");
+function createTableBody(props) {
+  const columns = readProp(props, "columns", []);
+  const rows = readProp(props, "rows", []);
+  if (rows.length === 0) return createEmptyRow(props, columns.length);
+  return createFragment((parent, anchor) => {
+    for (let index = 0; index < rows.length; index++) {
+      insertBefore(parent, createTableRow(rows[index], index, columns, props), anchor);
+    }
+  });
+}
+__name(createTableBody, "createTableBody");
+function createTableRow(row, index, columns, props) {
+  const tableRow = createElement("tr");
+  const rowKey = readProp(props, "rowKey", void 0);
+  if (rowKey) setOptionalAttribute(tableRow, "data-row-key", rowKey(row, index));
+  for (const column of columns) {
+    const cell = createElement("td");
+    setAttribute(cell, "data-column-id", column.id);
+    applyAlignment(cell, column.align);
+    insertDynamic(cell, null, () => {
+      const value = column.render ? column.render(row, index) : column.key === void 0 ? void 0 : readRowValue(row, column.key);
+      return resolveSlot(value);
+    });
+    insertBefore(tableRow, cell, null);
+  }
+  const onRowClick = readProp(props, "onRowClick", void 0);
+  if (onRowClick) {
+    setProperty(tableRow, "tabIndex", 0);
+    setAttribute(tableRow, "data-clickable", "true");
+    addEventListener(tableRow, "click", () => onRowClick(row, index));
+  }
+  return tableRow;
+}
+__name(createTableRow, "createTableRow");
+function createEmptyRow(props, columnCount) {
+  const row = createElement("tr");
+  const cell = createElement("td");
+  setAttribute(cell, "colspan", String(Math.max(1, columnCount)));
+  if (hasProp(props, "empty")) {
+    insertDynamic(cell, null, () => resolveSlot(Reflect.get(props, "empty")));
+  } else {
+    insertBefore(cell, createText("No data"), null);
+  }
+  insertBefore(row, cell, null);
+  return row;
+}
+__name(createEmptyRow, "createEmptyRow");
+function applyAlignment(cell, align) {
+  if (align === "end") {
+    setAttribute(cell, "class", "num");
+    setAttribute(cell, "data-align", "end");
+  } else if (align === "center") {
+    setAttribute(cell, "data-align", "center");
+  }
+}
+__name(applyAlignment, "applyAlignment");
+function readRowValue(row, key) {
+  if (row === null || row === void 0) return void 0;
+  return Reflect.get(row, key);
+}
+__name(readRowValue, "readRowValue");
+
+// packages/ui/src/stat-card.ts
+function StatCard(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-statcard"]);
+  bindCommonAttributes(root, props, [
+    "label",
+    "value",
+    "delta",
+    "deltaDirection",
+    "deltaIcon",
+    "deltaCaption"
+  ]);
+  bindUserStyle(root, props);
+  if (hasProp(props, "label")) {
+    const label = createElement("span");
+    const text = createText("");
+    setAttribute(label, "class", "vui-statcard__label");
+    bindTextContent(text, () => readProp(props, "label", ""));
+    insertBefore(label, text, null);
+    insertBefore(root, label, null);
+  }
+  if (hasProp(props, "value")) {
+    const value = createElement("span");
+    setAttribute(value, "class", "vui-statcard__value");
+    insertDynamic(value, null, () => resolveSlot(Reflect.get(props, "value")));
+    insertBefore(root, value, null);
+  }
+  if (hasProp(props, "delta") || hasProp(props, "deltaIcon") || hasProp(props, "deltaCaption")) {
+    const delta = createElement("span");
+    effect(() => {
+      const direction = readProp(props, "deltaDirection", void 0);
+      setAttribute(delta, "class", `vui-statcard__delta${direction ? ` is-${direction}` : ""}`);
+    });
+    if (hasProp(props, "deltaIcon")) mountSlot(delta, props, "deltaIcon");
+    if (hasProp(props, "delta")) mountSlot(delta, props, "delta");
+    if (hasProp(props, "deltaCaption")) {
+      const caption = createElement("span");
+      setAttribute(caption, "class", "vui-statcard__caption");
+      mountSlot(caption, props, "deltaCaption");
+      insertBefore(delta, caption, null);
+    }
+    insertBefore(root, delta, null);
+  }
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(StatCard, "StatCard");
+function StatCardGrid(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-statcard__grid"]);
+  bindCommonAttributes(root, props);
+  bindUserStyle(root, props);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(StatCardGrid, "StatCardGrid");
+
+// packages/ui/src/kbd.ts
+function Kbd(props = {}) {
+  const root = createElement("kbd");
+  bindClassList(root, props, () => ["vui-kbd"]);
+  bindCommonAttributes(root, props);
+  bindUserStyle(root, props);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Kbd, "Kbd");
+function KbdCombo(props = {}) {
+  const root = createElement("span");
+  bindClassList(root, props, () => ["vui-kbd__combo"]);
+  bindCommonAttributes(root, props, ["keys", "separator"]);
+  bindUserStyle(root, props);
+  if (hasProp(props, "keys")) insertDynamic(root, null, () => createComboKeys(props));
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(KbdCombo, "KbdCombo");
+function KbdRow(props = {}) {
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-kbd__row"]);
+  bindCommonAttributes(root, props);
+  bindUserStyle(root, props);
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(KbdRow, "KbdRow");
+function createComboKeys(props) {
+  const keys = readProp(props, "keys", []);
+  const separator = readProp(props, "separator", "+");
+  return createFragment((parent, anchor) => {
+    for (let index = 0; index < keys.length; index++) {
+      if (index > 0) {
+        const plus = createElement("span");
+        setAttribute(plus, "class", "vui-kbd__plus");
+        const separatorNode = resolveSlot(separator);
+        if (separatorNode) insertBefore(plus, separatorNode, null);
+        insertBefore(parent, plus, anchor);
+      }
+      insertBefore(parent, Kbd({ children: keys[index] }), anchor);
+    }
+  });
+}
+__name(createComboKeys, "createComboKeys");
+
+// packages/ui/src/activity-rail.ts
+function ActivityRail(props = {}) {
+  const root = createElement("nav");
+  const internalValue = state(void 0);
+  bindClassList(root, props, () => ["vui-activityrail"]);
+  bindCommonAttributes(root, props, ["items", "value", "defaultValue", "onChange"]);
+  bindUserStyle(root, props);
+  if (!hasProp(props, "aria-label")) setAttribute(root, "aria-label", "Activity");
+  if (hasProp(props, "items")) insertDynamic(root, null, () => createActivityItems(props, internalValue));
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(ActivityRail, "ActivityRail");
+function createActivityItems(props, internalValue) {
+  const items = readProp(props, "items", []);
+  const selected = activeId3(props, items, internalValue);
+  return createFragment((parent, anchor) => {
+    for (const item of items) {
+      if (item.divider === true) {
+        const divider = createElement("div");
+        setAttribute(divider, "class", "vui-activityrail__divider");
+        setAttribute(divider, "role", "separator");
+        insertBefore(parent, divider, anchor);
+        continue;
+      }
+      if (item.spacer === true) {
+        const spacer = createElement("span");
+        setAttribute(spacer, "class", "vui-activityrail__spacer");
+        insertBefore(parent, spacer, anchor);
+        continue;
+      }
+      insertBefore(parent, createActivityButton(item, props, selected, internalValue), anchor);
+    }
+  });
+}
+__name(createActivityItems, "createActivityItems");
+function createActivityButton(item, props, selected, internalValue) {
+  const button = createElement("button");
+  const active = item.id !== void 0 && item.id === selected;
+  setAttribute(button, "class", `vui-activityrail__btn${active ? " is-active" : ""}`);
+  setAttribute(button, "type", "button");
+  setOptionalAttribute(button, "aria-label", item.label);
+  setOptionalAttribute(button, "title", item.label);
+  setAttribute(button, "aria-pressed", active ? "true" : "false");
+  if (item.disabled === true) {
+    setProperty(button, "disabled", true);
+    setAttribute(button, "aria-disabled", "true");
+  }
+  if (item.icon !== void 0) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-activityrail__icon");
+    mountSlot(icon, item, "icon");
+    insertBefore(button, icon, null);
+  } else if (item.label !== void 0) {
+    insertBefore(button, createText(item.label), null);
+  }
+  addEventListener(button, "click", (event) => {
+    if (item.disabled === true || item.id === void 0) return;
+    if (readProp(props, "value", void 0) === void 0) internalValue.value = item.id;
+    const handler = readProp(props, "onChange", void 0);
+    if (typeof handler === "function") handler(item.id, event);
+  });
+  return button;
+}
+__name(createActivityButton, "createActivityButton");
+function activeId3(props, items, internalValue) {
+  const controlled = readProp(props, "value", void 0);
+  if (controlled !== void 0) return controlled;
+  if (internalValue.value !== void 0) return internalValue.value;
+  const defaultValue = readProp(props, "defaultValue", void 0);
+  if (defaultValue !== void 0) return defaultValue;
+  return items.find((item) => item.id !== void 0)?.id;
+}
+__name(activeId3, "activeId");
+
+// packages/ui/src/file-tree.ts
+function FileTree(props = {}) {
+  const items = readProp(props, "items", []);
+  const internalExpanded = state(initialExpanded(props, items));
+  const root = createElement("div");
+  bindClassList(root, props, () => ["vui-filetree"]);
+  bindCommonAttributes(root, props, [
+    "items",
+    "value",
+    "defaultValue",
+    "expanded",
+    "defaultExpanded",
+    "onSelect",
+    "onToggle"
+  ]);
+  bindUserStyle(root, props);
+  if (!hasProp(props, "role")) setAttribute(root, "role", "tree");
+  if (!hasProp(props, "aria-label")) setAttribute(root, "aria-label", "Files");
+  insertDynamic(root, null, () => createTreeRows(props, internalExpanded));
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(FileTree, "FileTree");
+function createTreeRows(props, internalExpanded) {
+  const items = readProp(props, "items", []);
+  const expanded = new Set(readProp(props, "expanded", void 0) ?? internalExpanded.value);
+  const visible = flattenVisible(items, expanded);
+  const selected = activeId4(props, items);
+  return createFragment((parent, anchor) => {
+    for (const entry of visible) {
+      insertBefore(parent, createTreeRow(entry, props, internalExpanded, selected, expanded), anchor);
+    }
+  });
+}
+__name(createTreeRows, "createTreeRows");
+function createTreeRow(entry, props, internalExpanded, selected, expanded) {
+  const { item } = entry;
+  const isFolder = item.kind === "folder";
+  const hasChildren = isFolder && Boolean(item.children?.length);
+  const active = item.id === selected;
+  const row = createElement("div");
+  setAttribute(row, "class", `vui-filetree__row${active ? " is-active" : ""}`);
+  setAttribute(row, "role", "treeitem");
+  setAttribute(row, "data-depth", String(entry.depth));
+  setAttribute(row, "data-file-id", item.id);
+  setProperty(row, "tabIndex", item.disabled === true ? -1 : 0);
+  if (active) setAttribute(row, "aria-selected", "true");
+  if (isFolder) setAttribute(row, "aria-expanded", entry.expanded ? "true" : "false");
+  if (item.disabled === true) setAttribute(row, "aria-disabled", "true");
+  const chevron = createElement("span");
+  setAttribute(chevron, "class", `vui-filetree__chevron${hasChildren ? "" : " vui-filetree__chevron--leaf"}`);
+  if (hasChildren) {
+    if (item.chevron !== void 0) mountSlot(chevron, item, "chevron");
+    else insertBefore(chevron, createText(entry.expanded ? "v" : ">"), null);
+  }
+  insertBefore(row, chevron, null);
+  if (item.icon !== void 0) {
+    const icon = createElement("span");
+    setAttribute(icon, `class`, `vui-filetree__icon ${fileIconClass(item)}`.trim());
+    mountSlot(icon, item, "icon");
+    insertBefore(row, icon, null);
+  }
+  const label = createElement("span");
+  setAttribute(label, "class", "vui-filetree__label");
+  setOptionalAttribute(label, "title", item.label);
+  insertBefore(label, createText(item.label), null);
+  insertBefore(row, label, null);
+  addEventListener(row, "click", (event) => {
+    if (item.disabled === true) return;
+    if (isFolder && hasChildren) {
+      const nextExpanded = !expanded.has(item.id);
+      if (readProp(props, "expanded", void 0) === void 0) {
+        const next = new Set(internalExpanded.value);
+        if (nextExpanded) next.add(item.id);
+        else next.delete(item.id);
+        internalExpanded.value = [...next];
+      }
+      const onToggle = readProp(props, "onToggle", void 0);
+      if (typeof onToggle === "function") {
+        onToggle(item.id, nextExpanded, event);
+      }
+    }
+    const onSelect = readProp(props, "onSelect", void 0);
+    if (typeof onSelect === "function") onSelect(item.id, event);
+  });
+  addEventListener(row, "keydown", (event) => {
+    const keyboardEvent = event;
+    if (keyboardEvent.key !== "Enter" && keyboardEvent.key !== " ") return;
+    keyboardEvent.preventDefault?.();
+    row.dispatchEvent?.(new MouseEvent("click", { bubbles: true }));
+  });
+  return row;
+}
+__name(createTreeRow, "createTreeRow");
+function flattenVisible(items, expanded, depth = 0) {
+  const visible = [];
+  for (const item of items) {
+    const folder = item.kind === "folder";
+    const open = folder && expanded.has(item.id);
+    visible.push({ item, depth, expanded: open });
+    if (open && item.children) visible.push(...flattenVisible(item.children, expanded, depth + 1));
+  }
+  return visible;
+}
+__name(flattenVisible, "flattenVisible");
+function initialExpanded(props, items) {
+  const ids = new Set(readProp(props, "defaultExpanded", []));
+  collectExpanded(items, ids);
+  return [...ids];
+}
+__name(initialExpanded, "initialExpanded");
+function collectExpanded(items, ids) {
+  for (const item of items) {
+    if (item.expanded === true) ids.add(item.id);
+    if (item.children) collectExpanded(item.children, ids);
+  }
+}
+__name(collectExpanded, "collectExpanded");
+function activeId4(props, items) {
+  const controlled = readProp(props, "value", void 0);
+  if (controlled !== void 0) return controlled;
+  const defaultValue = readProp(props, "defaultValue", void 0);
+  if (defaultValue !== void 0) return defaultValue;
+  return findActive(items);
+}
+__name(activeId4, "activeId");
+function findActive(items) {
+  for (const item of items) {
+    if (item.active === true) return item.id;
+    if (item.children) {
+      const nested = findActive(item.children);
+      if (nested !== void 0) return nested;
+    }
+  }
+  return void 0;
+}
+__name(findActive, "findActive");
+function fileIconClass(item) {
+  if (item.kind === "folder") return "vui-filetree__icon--folder";
+  const extension = item.label.slice(item.label.lastIndexOf(".") + 1).toLowerCase();
+  if (extension === "ts" || extension === "tsx") return "vui-filetree__icon--ts";
+  if (extension === "css" || extension === "scss") return "vui-filetree__icon--css";
+  if (extension === "json") return "vui-filetree__icon--json";
+  return "";
+}
+__name(fileIconClass, "fileIconClass");
+
+// packages/ui/src/editor-tabs.ts
+function EditorTabs(props = {}) {
+  const root = createElement("div");
+  const internalValue = state(void 0);
+  bindClassList(root, props, () => ["vui-editortabs"]);
+  bindCommonAttributes(root, props, [
+    "tabs",
+    "value",
+    "defaultValue",
+    "closeIcon",
+    "actions",
+    "onChange",
+    "onClose"
+  ]);
+  bindUserStyle(root, props);
+  insertDynamic(root, null, () => createEditorTabs(props, internalValue));
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(EditorTabs, "EditorTabs");
+function createEditorTabs(props, internalValue) {
+  const tabs = readProp(props, "tabs", []);
+  const selected = activeId5(props, tabs, internalValue);
+  return createFragment((parent, anchor) => {
+    for (const tab of tabs) {
+      insertBefore(parent, createEditorTab(tab, tabs, selected, props, internalValue), anchor);
+    }
+    const spacer = createElement("span");
+    setAttribute(spacer, "class", "vui-editortabs__spacer");
+    insertBefore(parent, spacer, anchor);
+    if (hasProp(props, "actions")) {
+      const actions = createElement("span");
+      setAttribute(actions, "class", "vui-editortabs__actions");
+      mountSlot(actions, props, "actions");
+      insertBefore(parent, actions, anchor);
+    }
+  });
+}
+__name(createEditorTabs, "createEditorTabs");
+function createEditorTab(tab, tabs, selected, props, internalValue) {
+  const active = tab.id === selected;
+  const root = createElement("span");
+  setAttribute(root, "class", `vui-editortab${active ? " is-active" : ""}`);
+  setAttribute(root, "role", "tab");
+  setAttribute(root, "aria-selected", active ? "true" : "false");
+  setAttribute(root, "tabindex", active ? "0" : "-1");
+  setOptionalAttribute(root, "data-editor-tab-id", tab.id);
+  if (tab.disabled === true) setAttribute(root, "aria-disabled", "true");
+  if (tab.icon !== void 0) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "ic");
+    mountSlot(icon, tab, "icon");
+    insertBefore(root, icon, null);
+  }
+  const label = createElement("span");
+  setAttribute(label, "class", "vui-editortab__label");
+  insertBefore(label, createText(tab.label), null);
+  insertBefore(root, label, null);
+  if (tab.closeable === true) {
+    const close = createElement("button");
+    setAttribute(close, "class", "close");
+    setAttribute(close, "type", "button");
+    setAttribute(close, "aria-label", `Close ${tab.label}`);
+    const closeIcon = tab.closeIcon ?? readProp(props, "closeIcon", void 0);
+    const icon = closeIcon === void 0 ? createText("x") : resolveSlot(closeIcon);
+    if (icon) insertBefore(close, icon, null);
+    addEventListener(close, "click", (event) => {
+      event.stopPropagation?.();
+      const handler = readProp(props, "onClose", void 0);
+      if (typeof handler === "function") handler(tab.id, event);
+    });
+    insertBefore(root, close, null);
+  }
+  addEventListener(root, "click", (event) => {
+    if (tab.disabled === true) return;
+    selectTab(tab.id, props, internalValue, event);
+  });
+  addEventListener(root, "keydown", (event) => {
+    const keyboardEvent = event;
+    if (keyboardEvent.key === "Enter" || keyboardEvent.key === " ") {
+      keyboardEvent.preventDefault?.();
+      if (tab.disabled !== true) selectTab(tab.id, props, internalValue, keyboardEvent);
+      return;
+    }
+    if (keyboardEvent.key !== "ArrowLeft" && keyboardEvent.key !== "ArrowRight") return;
+    keyboardEvent.preventDefault?.();
+    const direction = keyboardEvent.key === "ArrowLeft" ? -1 : 1;
+    const next = adjacentTab(tabs, tab.id, direction);
+    if (next) selectTab(next.id, props, internalValue, keyboardEvent);
+  });
+  return root;
+}
+__name(createEditorTab, "createEditorTab");
+function selectTab(id, props, internalValue, event) {
+  if (readProp(props, "value", void 0) === void 0) internalValue.value = id;
+  const handler = readProp(props, "onChange", void 0);
+  if (typeof handler === "function") handler(id, event);
+}
+__name(selectTab, "selectTab");
+function adjacentTab(tabs, id, direction) {
+  const start = tabs.findIndex((tab) => tab.id === id);
+  if (start < 0) return void 0;
+  for (let index = start + direction; index >= 0 && index < tabs.length; index += direction) {
+    if (tabs[index].disabled !== true) return tabs[index];
+  }
+  return void 0;
+}
+__name(adjacentTab, "adjacentTab");
+function activeId5(props, tabs, internalValue) {
+  const controlled = readProp(props, "value", void 0);
+  if (controlled !== void 0) return controlled;
+  if (internalValue.value !== void 0) return internalValue.value;
+  const defaultValue = readProp(props, "defaultValue", void 0);
+  if (defaultValue !== void 0) return defaultValue;
+  return tabs.find((tab) => tab.disabled !== true)?.id;
+}
+__name(activeId5, "activeId");
+
+// packages/ui/src/workbench-titlebar.ts
+function WorkbenchTitlebar(props = {}) {
+  const root = createElement("header");
+  const left = createElement("div");
+  const right = createElement("div");
+  bindClassList(root, props, () => ["vui-wbtitlebar"]);
+  bindCommonAttributes(root, props, [
+    "mode",
+    "modeIcon",
+    "project",
+    "projectIcon",
+    "projectChevron",
+    "actions",
+    "windowControls",
+    "onWindowClose",
+    "onWindowMinimize",
+    "onWindowMaximize",
+    "onProjectClick"
+  ]);
+  bindUserStyle(root, props);
+  setAttribute(left, "class", "vui-wbtitlebar__left");
+  setAttribute(right, "class", "vui-wbtitlebar__right");
+  insertDynamic(left, null, () => createTitlebarLeft(props));
+  if (hasProp(props, "actions")) mountSlot(right, props, "actions");
+  if (hasProp(props, "children")) mountSlot(right, props, "children");
+  insertBefore(root, left, null);
+  insertBefore(root, right, null);
+  return root;
+}
+__name(WorkbenchTitlebar, "WorkbenchTitlebar");
+function createTitlebarLeft(props) {
+  return createFragment((parent, anchor) => {
+    if (readProp(props, "windowControls", true)) {
+      const lights = createElement("div");
+      setAttribute(lights, "class", "vui-wbtitlebar__lights");
+      insertBefore(lights, createWindowLight("close", props, "onWindowClose"), null);
+      insertBefore(lights, createWindowLight("min", props, "onWindowMinimize"), null);
+      insertBefore(lights, createWindowLight("max", props, "onWindowMaximize"), null);
+      insertBefore(parent, lights, anchor);
+    }
+    if (hasProp(props, "mode")) {
+      const mode = createElement("span");
+      setAttribute(mode, "class", "vui-wbtitlebar__mode-chip");
+      if (hasProp(props, "modeIcon")) {
+        const icon = createElement("span");
+        setAttribute(icon, "class", "vui-wbtitlebar__mode-icon");
+        mountSlot(icon, props, "modeIcon");
+        insertBefore(mode, icon, null);
+      }
+      const text = createText("");
+      bindTextContent(text, () => readProp(props, "mode", ""));
+      insertBefore(mode, text, null);
+      insertBefore(parent, mode, anchor);
+    }
+    if (hasProp(props, "project")) insertBefore(parent, createProjectSelector(props), anchor);
+  });
+}
+__name(createTitlebarLeft, "createTitlebarLeft");
+function createWindowLight(kind, props, handlerName) {
+  const light = createElement("button");
+  setAttribute(light, "class", `vui-wbtitlebar__light vui-wbtitlebar__light--${kind}`);
+  setAttribute(light, "type", "button");
+  setAttribute(light, "aria-label", kind === "close" ? "Close window" : kind === "min" ? "Minimize window" : "Maximize window");
+  addEventListener(light, "click", (event) => {
+    const handler = readProp(props, handlerName, void 0);
+    if (typeof handler === "function") handler(event);
+  });
+  return light;
+}
+__name(createWindowLight, "createWindowLight");
+function createProjectSelector(props) {
+  const button = createElement("button");
+  setAttribute(button, "class", "vui-wbtitlebar__project-selector");
+  setAttribute(button, "type", "button");
+  setOptionalAttribute(button, "aria-label", readProp(props, "project", "Project"));
+  if (hasProp(props, "projectIcon")) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-wbtitlebar__project-icon");
+    mountSlot(icon, props, "projectIcon");
+    insertBefore(button, icon, null);
+  }
+  const project = createText("");
+  bindTextContent(project, () => readProp(props, "project", ""));
+  insertBefore(button, project, null);
+  if (hasProp(props, "projectChevron")) {
+    const chevron = createElement("span");
+    setAttribute(chevron, "class", "vui-wbtitlebar__project-chevron");
+    mountSlot(chevron, props, "projectChevron");
+    insertBefore(button, chevron, null);
+  }
+  addEventListener(button, "click", (event) => {
+    const handler = readProp(props, "onProjectClick", void 0);
+    if (typeof handler === "function") handler(event);
+  });
+  return button;
+}
+__name(createProjectSelector, "createProjectSelector");
+
+// packages/ui/src/status-bar.ts
+function StatusBar(props = {}) {
+  const root = createElement("footer");
+  bindClassList(root, props, () => ["vui-statusbar"]);
+  bindCommonAttributes(root, props, ["left", "right", "onItemClick"]);
+  bindUserStyle(root, props);
+  setAttribute(root, "role", "status");
+  if (hasProp(props, "left")) insertDynamic(root, null, () => createStatusGroup(props, "left"));
+  if (hasProp(props, "right") || hasProp(props, "children")) {
+    const group = createElement("div");
+    setAttribute(group, "class", "vui-statusbar__group");
+    if (hasProp(props, "right")) insertDynamic(group, null, () => createStatusItems(props, "right"));
+    if (hasProp(props, "children")) mountSlot(group, props, "children");
+    insertBefore(root, group, null);
+  }
+  return root;
+}
+__name(StatusBar, "StatusBar");
+function createStatusGroup(props, side) {
+  const group = createElement("div");
+  setAttribute(group, "class", "vui-statusbar__group");
+  insertDynamic(group, null, () => createStatusItems(props, side));
+  return group;
+}
+__name(createStatusGroup, "createStatusGroup");
+function createStatusItems(props, side) {
+  const items = side === "left" ? readProp(props, "left", []) : readProp(props, "right", []);
+  return createFragment((parent, anchor) => {
+    for (const item of items) insertBefore(parent, createStatusItem(item, props), anchor);
+  });
+}
+__name(createStatusItems, "createStatusItems");
+function createStatusItem(item, props) {
+  const root = createElement("span");
+  setAttribute(root, "class", "vui-statusbar__item");
+  if (item.id !== void 0 && readProp(props, "onItemClick", void 0)) {
+    setAttribute(root, "role", "button");
+    setAttribute(root, "tabindex", item.disabled === true ? "-1" : "0");
+  }
+  if (item.disabled === true) setAttribute(root, "aria-disabled", "true");
+  if (item.icon !== void 0) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-statusbar__icon");
+    mountSlot(icon, item, "icon");
+    insertBefore(root, icon, null);
+  }
+  if (item.dot !== void 0) {
+    const dot = createElement("span");
+    setAttribute(dot, "class", `vui-statusbar__dot vui-statusbar__dot--${item.dot}`);
+    setAttribute(dot, "aria-hidden", "true");
+    insertBefore(root, dot, null);
+  }
+  if (item.label !== void 0) mountSlot(root, item, "label");
+  const activate = /* @__PURE__ */ __name((event) => {
+    if (item.disabled === true || item.id === void 0) return;
+    const handler = readProp(props, "onItemClick", void 0);
+    if (typeof handler === "function") handler(item.id, event);
+  }, "activate");
+  if (item.id !== void 0) {
+    addEventListener(root, "click", activate);
+    addEventListener(root, "keydown", (event) => {
+      const keyboardEvent = event;
+      if (keyboardEvent.key !== "Enter" && keyboardEvent.key !== " ") return;
+      keyboardEvent.preventDefault?.();
+      activate(keyboardEvent);
+    });
+  }
+  return root;
+}
+__name(createStatusItem, "createStatusItem");
+
+// packages/ui/src/chat-composer.ts
+function ChatComposer(props = {}) {
+  const root = createElement("div");
+  const input = createElement("textarea");
+  const toolbar = createElement("div");
+  const tools = createElement("div");
+  const actions = createElement("div");
+  bindClassList(root, props, () => ["vui-composer"]);
+  bindUserStyle(root, props);
+  bindCommonAttributes(input, props, [
+    "value",
+    "placeholder",
+    "disabled",
+    "model",
+    "modelIcon",
+    "modelChevron",
+    "tools",
+    "actions",
+    "sendIcon",
+    "sendLabel",
+    "onInput",
+    "onSubmit",
+    "onSend",
+    "onModelClick"
+  ]);
+  setAttribute(input, "class", "vui-composer__input");
+  setAttribute(toolbar, "class", "vui-composer__toolbar");
+  setAttribute(tools, "class", "vui-composer__tools");
+  setAttribute(actions, "class", "vui-composer__actions");
+  effect(() => {
+    setOptionalAttribute(input, "placeholder", readProp(props, "placeholder", void 0));
+    setOptionalProperty(input, "disabled", readProp(props, "disabled", false));
+    setOptionalAttribute(input, "aria-disabled", readProp(props, "disabled", false) ? "true" : void 0);
+  });
+  if (hasProp(props, "value")) {
+    bindPropertyValue(input, "value", () => readProp(props, "value", "") ?? "");
+  }
+  listen(input, "input", props, "onInput", () => readProp(props, "disabled", false));
+  addEventListener(input, "keydown", (event) => {
+    const keyboardEvent = event;
+    if (keyboardEvent.key !== "Enter" || !keyboardEvent.metaKey && !keyboardEvent.ctrlKey) return;
+    keyboardEvent.preventDefault?.();
+    const handler = readProp(props, "onSubmit", void 0);
+    if (typeof handler === "function") handler(currentValue(input, props), keyboardEvent);
+  });
+  if (hasProp(props, "tools")) mountSlot(tools, props, "tools");
+  else if (hasProp(props, "children")) mountSlot(tools, props, "children");
+  if (hasProp(props, "model")) insertBefore(tools, createModelSelector(props), null);
+  if (hasProp(props, "actions")) mountSlot(actions, props, "actions");
+  else insertBefore(actions, createSendButton(input, props), null);
+  insertBefore(root, input, null);
+  insertBefore(toolbar, tools, null);
+  insertBefore(toolbar, actions, null);
+  insertBefore(root, toolbar, null);
+  return root;
+}
+__name(ChatComposer, "ChatComposer");
+function createModelSelector(props) {
+  const button = createElement("button");
+  setAttribute(button, "class", "vui-composer__model");
+  setAttribute(button, "type", "button");
+  if (hasProp(props, "modelIcon")) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-composer__model-icon");
+    mountSlot(icon, props, "modelIcon");
+    insertBefore(button, icon, null);
+  }
+  const text = createText("");
+  bindTextContent(text, () => readProp(props, "model", ""));
+  insertBefore(button, text, null);
+  if (hasProp(props, "modelChevron")) {
+    const chevron = createElement("span");
+    setAttribute(chevron, "class", "vui-composer__model-chevron");
+    mountSlot(chevron, props, "modelChevron");
+    insertBefore(button, chevron, null);
+  }
+  addEventListener(button, "click", (event) => {
+    const handler = readProp(props, "onModelClick", void 0);
+    if (typeof handler === "function") handler(event);
+  });
+  return button;
+}
+__name(createModelSelector, "createModelSelector");
+function createSendButton(input, props) {
+  const button = createElement("button");
+  setAttribute(button, "class", "vui-composer__send");
+  setAttribute(button, "type", "button");
+  const label = readProp(props, "sendLabel", "Send");
+  setOptionalAttribute(button, "aria-label", label);
+  if (hasProp(props, "sendIcon")) {
+    const icon = createElement("span");
+    setAttribute(icon, "class", "vui-composer__send-icon");
+    mountSlot(icon, props, "sendIcon");
+    insertBefore(button, icon, null);
+  } else {
+    insertBefore(button, createText(label), null);
+  }
+  effect(() => setProperty(button, "disabled", readProp(props, "disabled", false)));
+  addEventListener(button, "click", (event) => {
+    if (readProp(props, "disabled", false)) return;
+    const handler = readProp(props, "onSend", void 0);
+    if (typeof handler === "function") handler(currentValue(input, props), event);
+  });
+  return button;
+}
+__name(createSendButton, "createSendButton");
+function currentValue(input, props) {
+  const value = Reflect.get(input, "value");
+  return typeof value === "string" ? value : readProp(props, "value", "") ?? "";
+}
+__name(currentValue, "currentValue");
+
+// packages/ui/src/drawer.ts
+function Drawer(props = {}) {
+  const root = createElement("div");
+  const surface = createElement("aside");
+  const body = createElement("div");
+  bindClassList(root, props, () => ["vui-backdrop"]);
+  bindUserStyle(root, props);
+  bindCommonAttributes(surface, props, [
+    "open",
+    "title",
+    "side",
+    "closeOnBackdrop",
+    "closeOnEscape",
+    "modal",
+    "titleId",
+    "descriptionId",
+    "closeLabel",
+    "footer",
+    "onClose",
+    "portal",
+    "portalTarget"
+  ]);
+  setAttribute(root, "role", "presentation");
+  setAttribute(surface, "class", "vui-drawer");
+  setAttribute(surface, "role", "dialog");
+  setAttribute(body, "class", "vui-drawer__body");
+  effect(() => {
+    const open = readProp(props, "open", false);
+    const modal = readProp(props, "modal", true);
+    setOptionalProperty(root, "hidden", !open);
+    setOptionalAttribute(root, "data-state", open ? "open" : "closed");
+    setOptionalAttribute(surface, "aria-modal", modal ? "true" : "false");
+    setOptionalAttribute(surface, "aria-labelledby", readProp(props, "titleId", void 0));
+    setOptionalAttribute(surface, "aria-describedby", readProp(props, "descriptionId", void 0));
+    setOptionalAttribute(surface, "data-side", readProp(props, "side", "right"));
+  });
+  if (hasProp(props, "title") || hasProp(props, "onClose")) {
+    const head = createElement("header");
+    setAttribute(head, "class", "vui-drawer__head");
+    if (hasProp(props, "title")) {
+      const title = createElement("div");
+      const text = createText("");
+      setAttribute(title, "class", "vui-dialog__title");
+      bindTextContent(text, () => readProp(props, "title", ""));
+      insertBefore(title, text, null);
+      insertBefore(head, title, null);
+    }
+    if (hasProp(props, "onClose")) {
+      const close = createElement("button");
+      setAttribute(close, "class", "vui-dialog__close");
+      setAttribute(close, "type", "button");
+      setAttribute(close, "aria-label", readProp(props, "closeLabel", "Close"));
+      insertBefore(close, createText("x"), null);
+      addEventListener(close, "click", () => emitClose2(props, "close-button"));
+      insertBefore(head, close, null);
+    }
+    insertBefore(surface, head, null);
+  }
+  if (hasProp(props, "children")) mountSlot(body, props, "children");
+  insertBefore(surface, body, null);
+  if (hasProp(props, "footer")) {
+    const footer = createElement("footer");
+    setAttribute(footer, "class", "vui-dialog__foot");
+    mountSlot(footer, props, "footer");
+    insertBefore(surface, footer, null);
+  }
+  insertBefore(root, surface, null);
+  addEventListener(root, "click", (event) => {
+    if (event.target !== root) return;
+    if (readProp(props, "closeOnBackdrop", true)) emitClose2(props, "backdrop");
+  });
+  addEventListener(root, "keydown", (event) => {
+    if (event.key !== "Escape") return;
+    if (readProp(props, "closeOnEscape", true)) emitClose2(props, "escape");
+  });
+  const portal = readProp(props, "portal", void 0);
+  return portal ? createPortal(root, portal, readProp(props, "portalTarget", void 0)) : root;
+}
+__name(Drawer, "Drawer");
+function emitClose2(props, reason) {
+  if (!readProp(props, "open", false)) return;
+  const handler = readProp(props, "onClose", void 0);
+  if (typeof handler === "function") handler(reason);
+}
+__name(emitClose2, "emitClose");
+
+// packages/notification/src/index.ts
+var _NotificationError = class _NotificationError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "NotificationError";
+    this.code = code;
+  }
+};
+__name(_NotificationError, "NotificationError");
+var NotificationError = _NotificationError;
+var NOTIFICATION_KEY = createInjectionKey("vobs.notification");
+function useNotification() {
+  const notification = inject(NOTIFICATION_KEY);
+  if (!notification) {
+    throw new NotificationError("NOTIFICATION_CONTEXT_MISSING", "Vobs Notification: \u627E\u4E0D\u5230\u4E0A\u4E0B\u6587\uFF0C\u8BF7\u5B89\u88C5 notificationPlugin");
+  }
+  return notification;
+}
+__name(useNotification, "useNotification");
+
+// packages/icon-core/src/index.ts
+function createIcon(name, path, viewBox = "0 0 24 24") {
+  return { name, path, viewBox };
+}
+__name(createIcon, "createIcon");
+function createSvgIconNode(source, props = {}, options = {}) {
+  const root = createElement("span");
+  effect(() => {
+    updateSvgIconNode(root, typeof source === "function" ? source() : source, props, options);
+  });
+  return root;
+}
+__name(createSvgIconNode, "createSvgIconNode");
+function updateSvgIconNode(root, definition, props, options) {
+  const size = readProp2(props, "size", void 0);
+  const width = readProp2(props, "width", size);
+  const height = readProp2(props, "height", size);
+  const normalizedWidth = normalizeSvgLength(width);
+  const normalizedHeight = normalizeSvgLength(height);
+  const userClass = [
+    readProp2(props, "class", void 0),
+    readProp2(props, "className", void 0)
+  ].filter(hasText).join(" ");
+  const className = [options.class, options.className, userClass].filter(hasText).join(" ");
+  setAttribute(root, "class", className);
+  const internalStyle = size === void 0 ? "" : `width: ${normalizeCssLength(size)}; height: ${normalizeCssLength(size)}`;
+  const userStyle = readProp2(props, "style", void 0);
+  const style = [internalStyle, userStyle].filter(hasText).join("; ");
+  setOptionalAttribute2(root, "style", style || void 0);
+  const managedAttributes2 = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(props)) {
+    if (name === "class" || name === "className" || name === "style" || name === "children") continue;
+    if (!name.startsWith("aria-") && !name.startsWith("data-") && !["id", "title", "role", "tabIndex"].includes(name)) continue;
+    const value = Reflect.get(props, name);
+    if (value === void 0 || value === null || value === false) continue;
+    managedAttributes2.set(name === "tabIndex" ? "tabindex" : name, String(value));
+  }
+  for (const [name, value] of managedAttributes2) setAttribute(root, name, value);
+  clearStaleAttributes(root, managedAttributes2);
+  const title = readProp2(props, "title", void 0);
+  const ariaLabel = Reflect.get(props, "aria-label");
+  const decorative = readProp2(props, "decorative", title === void 0 && ariaLabel === void 0);
+  setOptionalAttribute2(root, "aria-hidden", decorative ? "true" : void 0);
+  setOptionalAttribute2(root, "aria-label", ariaLabel === void 0 ? title : void 0);
+  setOptionalAttribute2(root, "data-icon-name", options.dataIconName ?? definition?.name);
+  setOptionalAttribute2(root, "color", readProp2(props, "color", void 0));
+  if (!definition) {
+    setProperty(root, "innerHTML", "");
+    return;
+  }
+  const svgAttributes = {
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: definition.viewBox ?? "0 0 24 24",
+    ...options.defaultSvgAttributes,
+    ...definition.attributes,
+    ...normalizedWidth === void 0 ? {} : { width: normalizedWidth },
+    ...normalizedHeight === void 0 ? {} : { height: normalizedHeight },
+    ...readProp2(props, "color", void 0) === void 0 ? {} : { color: readProp2(props, "color", void 0) },
+    ...readProp2(props, "stroke", void 0) === void 0 ? {} : { stroke: readProp2(props, "stroke", void 0) },
+    ...readProp2(props, "fill", void 0) === void 0 ? {} : { fill: readProp2(props, "fill", void 0) },
+    ...readProp2(props, "strokeWidth", void 0) === void 0 ? {} : { "stroke-width": readProp2(props, "strokeWidth", void 0) }
+  };
+  const markup = Object.entries(svgAttributes).filter(([, value]) => value !== void 0).map(([name, value]) => `${name}="${escapeXml(String(value))}"`).join(" ");
+  const titleMarkup = title === void 0 ? "" : `<title>${escapeXml(title)}</title>`;
+  setProperty(root, "innerHTML", `<svg ${markup} aria-hidden="true">${titleMarkup}${definition.body}</svg>`);
+}
+__name(updateSvgIconNode, "updateSvgIconNode");
+function readProp2(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  return value === void 0 ? fallback : value;
+}
+__name(readProp2, "readProp");
+function hasText(value) {
+  return value !== void 0 && value.trim() !== "";
+}
+__name(hasText, "hasText");
+function normalizeSvgLength(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" ? String(value) : value;
+}
+__name(normalizeSvgLength, "normalizeSvgLength");
+function normalizeCssLength(value) {
+  return typeof value === "number" || /^\d+(?:\.\d+)?$/u.test(value) ? `${value}px` : value;
+}
+__name(normalizeCssLength, "normalizeCssLength");
+function setOptionalAttribute2(node, name, value) {
+  if (value === void 0 || value === null || value === false || value === "") {
+    node.removeAttribute(name);
+    return;
+  }
+  setAttribute(node, name, String(value));
+}
+__name(setOptionalAttribute2, "setOptionalAttribute");
+function clearStaleAttributes(node, next) {
+  const previous = node.__vobsIconAttributes ?? /* @__PURE__ */ new Set();
+  for (const name of previous) {
+    if (!next.has(name)) node.removeAttribute(name);
+  }
+  node.__vobsIconAttributes = new Set(next.keys());
+}
+__name(clearStaleAttributes, "clearStaleAttributes");
+function escapeXml(value) {
+  return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;");
+}
+__name(escapeXml, "escapeXml");
+
+// packages/ui/src/icon.ts
+function Icon(props = {}) {
+  const root = createSvgIconNode(() => {
+    const definition = resolveIcon(
+      readProp(props, "icon", void 0) ?? readProp(props, "name", void 0)
+    );
+    if (!definition) {
+      if (hasProp(props, "children")) return void 0;
+      throw new Error("Vobs UI: Icon requires a registered `name` or an `icon` definition");
+    }
+    return iconDefinitionToSvg(definition);
+  }, props, {
+    class: "vui-icon icon",
+    defaultSvgAttributes: {
+      fill: "none",
+      stroke: "currentColor",
+      "stroke-width": 2,
+      "stroke-linecap": "butt",
+      "stroke-linejoin": "miter"
+    }
+  });
+  if (hasProp(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Icon, "Icon");
+function iconDefinitionToSvg(definition) {
+  return {
+    name: definition.name,
+    body: definition.path,
+    viewBox: definition.viewBox
+  };
+}
+__name(iconDefinitionToSvg, "iconDefinitionToSvg");
+var VUI_ICON_PATHS = {
+  search: '<circle cx="11" cy="11" r="7"/><path d="m20 20-3.5-3.5"/>',
+  check: '<polyline points="4 12 10 18 20 6"/>',
+  x: '<line x1="6" y1="6" x2="18" y2="18"/><line x1="18" y1="6" x2="6" y2="18"/>',
+  plus: '<line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/>',
+  minus: '<line x1="5" y1="12" x2="19" y2="12"/>',
+  "chevron-right": '<polyline points="9 6 15 12 9 18"/>',
+  "chevron-down": '<polyline points="6 9 12 15 18 9"/>',
+  "chevron-up": '<polyline points="6 15 12 9 18 15"/>',
+  "chevron-left": '<polyline points="15 6 9 12 15 18"/>',
+  "arrow-left": '<line x1="20" y1="12" x2="4" y2="12"/><polyline points="10 6 4 12 10 18"/>',
+  "arrow-right": '<line x1="4" y1="12" x2="20" y2="12"/><polyline points="14 6 20 12 14 18"/>',
+  "arrow-up": '<line x1="12" y1="20" x2="12" y2="4"/><polyline points="6 10 12 4 18 10"/>',
+  "arrow-down": '<line x1="12" y1="4" x2="12" y2="20"/><polyline points="6 14 12 20 18 14"/>',
+  atom: '<circle cx="12" cy="12" r="2"/><ellipse cx="12" cy="12" rx="10" ry="4"/><ellipse cx="12" cy="12" rx="10" ry="4" transform="rotate(60 12 12)"/><ellipse cx="12" cy="12" rx="10" ry="4" transform="rotate(120 12 12)"/>',
+  globe: '<circle cx="12" cy="12" r="9"/><path d="M3 12h18M12 3a14 14 0 0 1 0 18M12 3a14 14 0 0 0 0 18"/>',
+  "arrow-expand": '<polyline points="14 4 20 4 20 10"/><line x1="14" y1="10" x2="20" y2="4"/><polyline points="10 20 4 20 4 14"/><line x1="10" y1="14" x2="4" y2="20"/>',
+  "arrow-minimize": '<polyline points="20 4 14 10 20 10"/><line x1="14" y1="10" x2="14" y2="4"/><polyline points="4 20 10 14 4 14"/><line x1="10" y1="14" x2="10" y2="20"/>',
+  "check-circle": '<circle cx="12" cy="12" r="9"/><polyline points="8 12 11 15 16 9"/>',
+  "alert-circle": '<circle cx="12" cy="12" r="9"/><line x1="12" y1="8" x2="12" y2="13"/><line x1="12" y1="16" x2="12" y2="16.01"/>',
+  "alert-triangle": '<path d="M12 3 22 20 2 20 Z"/><line x1="12" y1="10" x2="12" y2="15"/><line x1="12" y1="18" x2="12" y2="18.01"/>',
+  info: '<circle cx="12" cy="12" r="9"/><line x1="12" y1="11" x2="12" y2="16"/><line x1="12" y1="8" x2="12" y2="8.01"/>',
+  home: '<polygon points="3 11 12 3 21 11 21 21 14 21 14 14 10 14 10 21 3 21 3 11"/>',
+  user: '<path d="M4 21v-1a6 6 0 0 1 6-6h4a6 6 0 0 1 6 6v1"/><circle cx="12" cy="8" r="4"/>',
+  settings: '<circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.7 1.7 0 0 0 .3 1.8l.1.1a2 2 0 1 1-2.8 2.8l-.1-.1a1.7 1.7 0 0 0-1.8-.3 1.7 1.7 0 0 0-1 1.5V21a2 2 0 1 1-4 0v-.1a1.7 1.7 0 0 0-1-1.5 1.7 1.7 0 0 0-1.8.3l-.1.1a2 2 0 1 1-2.8-2.8l.1-.1a1.7 1.7 0 0 0 .3-1.8 1.7 1.7 0 0 0-1.5-1H3a2 2 0 1 1 0-4h.1a1.7 1.7 0 0 0 1.5-1 1.7 1.7 0 0 0-.3-1.8l-.1-.1a2 2 0 1 1 2.8-2.8l.1.1a1.7 1.7 0 0 0 1.8.3H9a1.7 1.7 0 0 0 1-1.5V3a2 2 0 1 1 4 0v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.8-.3l.1-.1a2 2 0 1 1 2.8 2.8l-.1.1a1.7 1.7 0 0 0-.3 1.8V9a1.7 1.7 0 0 0 1.5 1H21a2 2 0 1 1 0 4h-.1a1.7 1.7 0 0 0-1.5 1z"/>',
+  menu: '<line x1="4" y1="6" x2="20" y2="6"/><line x1="4" y1="12" x2="20" y2="12"/><line x1="4" y1="18" x2="20" y2="18"/>',
+  "more-h": '<circle cx="5" cy="12" r="1.5" fill="currentColor"/><circle cx="12" cy="12" r="1.5" fill="currentColor"/><circle cx="19" cy="12" r="1.5" fill="currentColor"/>',
+  calendar: '<rect x="3" y="5" width="18" height="16"/><line x1="3" y1="10" x2="21" y2="10"/><line x1="8" y1="3" x2="8" y2="7"/><line x1="16" y1="3" x2="16" y2="7"/>',
+  filter: '<polygon points="3 4 21 4 14 12 14 20 10 18 10 12 3 4"/>',
+  sort: '<path d="M8 20V4"/><polyline points="4 8 8 4 12 8"/><path d="M16 4v16"/><polyline points="12 16 16 20 20 16"/>',
+  edit: '<path d="M4 20h4l10-10-4-4L4 16v4z"/><path d="M14 6l4 4"/>',
+  trash: '<polyline points="4 6 20 6"/><path d="M6 6v14h12V6"/><path d="M9 6V4h6v2"/><line x1="10" y1="10" x2="10" y2="17"/><line x1="14" y1="10" x2="14" y2="17"/>',
+  download: '<path d="M12 3v12"/><polyline points="7 10 12 15 17 10"/><line x1="3" y1="21" x2="21" y2="21"/>',
+  upload: '<path d="M12 21V6"/><polyline points="7 11 12 6 17 11"/><line x1="3" y1="21" x2="21" y2="21"/>',
+  pause: '<line x1="9" y1="5" x2="9" y2="19"/><line x1="15" y1="5" x2="15" y2="19"/>',
+  play: '<polygon points="8 5 19 12 8 19 8 5"/>',
+  refresh: '<polyline points="21 4 21 10 15 10"/><polyline points="3 20 3 14 9 14"/><path d="M20.5 9A9 9 0 0 0 5 5.5L3 7M3.5 15A9 9 0 0 0 19 18.5L21 17"/>',
+  bell: '<path d="M6 8a6 6 0 0 1 12 0c0 7 3 8 3 8H3s3-1 3-8z"/><path d="M10 21a2 2 0 0 0 4 0"/>',
+  folder: '<path d="M3 6h6l2 3h10v10H3z"/>',
+  code: '<polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/>',
+  sparkles: '<path d="M12 3l1.8 4.2L18 9l-4.2 1.8L12 15l-1.8-4.2L6 9l4.2-1.8L12 3z"/><path d="M19 14l1 2.2 2.2 1-2.2 1L19 20.4l-1-2.2-2.2-1 2.2-1L19 14z"/>',
+  zap: '<polygon points="13 2 4 14 12 14 11 22 20 10 12 10 13 2"/>',
+  sun: '<circle cx="12" cy="12" r="4"/><line x1="12" y1="2" x2="12" y2="5"/><line x1="12" y1="19" x2="12" y2="22"/><line x1="2" y1="12" x2="5" y2="12"/><line x1="19" y1="12" x2="22" y2="12"/><line x1="4.6" y1="4.6" x2="6.7" y2="6.7"/><line x1="17.3" y1="17.3" x2="19.4" y2="19.4"/><line x1="4.6" y1="19.4" x2="6.7" y2="17.3"/><line x1="17.3" y1="6.7" x2="19.4" y2="4.6"/>',
+  moon: '<path d="M21 12.8A9 9 0 1 1 11.2 3a7 7 0 0 0 9.8 9.8z"/>',
+  terminal: '<polyline points="4 7 9 12 4 17"/><line x1="12" y1="17" x2="20" y2="17"/>'
+};
+var iconRegistry = new Map(
+  Object.entries(VUI_ICON_PATHS).map(([name, path]) => [name, { name, path }])
+);
+function registerIcon(icon) {
+  const previous = iconRegistry.get(icon.name);
+  iconRegistry.set(icon.name, icon);
+  return () => {
+    if (previous) iconRegistry.set(icon.name, previous);
+    else iconRegistry.delete(icon.name);
+  };
+}
+__name(registerIcon, "registerIcon");
+function resolveIcon(icon) {
+  return typeof icon === "string" ? iconRegistry.get(icon) : icon;
+}
+__name(resolveIcon, "resolveIcon");
+
+// packages/ui/src/toast.ts
+function ToastHost(props = {}) {
+  const notification = props.notification ?? useNotification();
+  const root = createElement("ol");
+  bindClassList(root, props, () => [
+    "vui-toast-host",
+    `vui-toast-host--${readProp(props, "position", "top-right")}`
+  ]);
+  bindCommonAttributes(root, props, ["notification", "position", "closeLabel", "portal", "portalTarget"]);
+  bindUserStyle(root, props);
+  setAttribute(root, "aria-label", "Notifications");
+  setAttribute(root, "role", "region");
+  insertList(root, null, () => notification.notifications.value, (entry) => createToast(entry, notification, readProp(props, "closeLabel", "Dismiss notification")), (entry) => entry.id);
+  const portal = readProp(props, "portal", void 0);
+  return portal ? createPortal(root, portal, readProp(props, "portalTarget", void 0)) : root;
+}
+__name(ToastHost, "ToastHost");
+function createToast(notification, context, closeLabel) {
+  const item = createElement("li");
+  const content = createElement("div");
+  const close = createElement("button");
+  setAttribute(item, "class", `vui-toast vui-toast--${notification.type}`);
+  setAttribute(item, "data-notification-id", notification.id);
+  setAttribute(item, "role", notification.type === "error" ? "alert" : "status");
+  setAttribute(content, "class", "vui-toast__content");
+  setAttribute(close, "class", "vui-toast__close");
+  setAttribute(close, "type", "button");
+  setAttribute(close, "aria-label", closeLabel);
+  addEventListener(close, "click", () => context.dismiss(notification.id));
+  if (notification.title) {
+    const title = createElement("div");
+    setAttribute(title, "class", "vui-toast__title");
+    insertBefore(title, createText(notification.title), null);
+    insertBefore(content, title, null);
+  }
+  const message = createElement("div");
+  setAttribute(message, "class", "vui-toast__message");
+  insertBefore(message, createText(notification.content), null);
+  insertBefore(content, message, null);
+  insertBefore(close, Icon({ name: "x", size: 16, decorative: true }), null);
+  insertBefore(item, content, null);
+  insertBefore(item, close, null);
+  return item;
+}
+__name(createToast, "createToast");
+
+export { ActivityRail, Alert, Avatar, Button, ButtonGroup, Card, CardHeader, ChatComposer, Checkbox, Dialog, Drawer, EditorTabs, FileTree, Icon, Input, Kbd, KbdCombo, KbdRow, Menu, MenuDivider, NavList, PageHeader, PageHeaderAction, Pagination, Radio, Select, StatCard, StatCardGrid, StatusBar, Switch, Table, TablePanel, Tabs, Tag, Textarea, ToastHost, VUI_ICON_PATHS, WorkbenchTitlebar, createDOMPortalAdapter, createFocusTrap, createIcon, createOverlayManager, createPortal, registerIcon, resolveIcon };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map