@vobs/theme 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -0,0 +1,765 @@
+'use strict';
+
+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;
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+function onDispose(cleanup) {
+  throw new Error("Vobs: onDispose \u5FC5\u987B\u5728 Owner \u4F5C\u7528\u57DF\u5185\u8C03\u7528");
+}
+__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();
+    }
+  };
+  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) {
+          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 = 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) {
+          cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  eff.run();
+  return eff;
+}
+__name(effect, "effect");
+var renderEffect = effect;
+
+// packages/reactivity/src/memo.ts
+function memo(compute) {
+  let cached;
+  let dirty = true;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const memoSubscriber = {
+    dependencies: /* @__PURE__ */ new Set(),
+    get disposed() {
+      return disposed;
+    },
+    notify() {
+      if (disposed || dirty) return;
+      dirty = true;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    }
+  };
+  const memoSignal = {
+    get value() {
+      const subscriber = getCurrentSubscriber();
+      if (subscriber && !subscriber.disposed) {
+        subscribers.add(subscriber);
+        trackDependency(memoSignal);
+      }
+      if (dirty) {
+        cleanupDependencies(memoSubscriber);
+        const previous = getCurrentSubscriber();
+        setCurrentSubscriber(memoSubscriber);
+        try {
+          cached = compute();
+          dirty = false;
+        } finally {
+          setCurrentSubscriber(previous);
+        }
+      }
+      return cached;
+    },
+    set value(_) {
+      throw new Error("memo: \u6D3E\u751F\u503C\u4E0D\u80FD\u76F4\u63A5\u8D4B\u503C");
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+      cleanupDependencies(memoSubscriber);
+    }
+  };
+  return memoSignal;
+}
+__name(memo, "memo");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+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();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createElement(tag) {
+  return getRenderer().createElement(tag);
+}
+__name(createElement, "createElement");
+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");
+
+// packages/runtime/src/fragment.ts
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+
+// packages/vobs/src/context.ts
+var ownerProviders = /* @__PURE__ */ new WeakMap();
+function provide(key, value, options = {}) {
+  throw new Error("Vobs: provide \u5FC5\u987B\u5728\u7EC4\u4EF6\u6216 Owner \u4F5C\u7528\u57DF\u5185\u8C03\u7528");
+}
+__name(provide, "provide");
+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 provideToOwner(owner, key, value, options = {}) {
+  let providers = ownerProviders.get(owner);
+  if (!providers) {
+    providers = /* @__PURE__ */ new Map();
+    ownerProviders.set(owner, providers);
+    owner.onDispose(() => ownerProviders.delete(owner));
+  }
+  if (providers.has(key) && !options.override) {
+    throw new Error(`Vobs: \u6CE8\u5165\u9879 ${String(key)} \u5DF2\u5B58\u5728\uFF1B\u5982\u9700\u8986\u76D6\u8BF7\u4F20\u5165 override: true`);
+  }
+  providers.set(key, value);
+}
+__name(provideToOwner, "provideToOwner");
+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/theme/src/index.ts
+var THEME_KEY = createInjectionKey("vobs.theme");
+var defaultLightTheme = {
+  colorScheme: "light",
+  brand: {
+    primary: "#2563eb",
+    secondary: "#0f766e",
+    accent: "#d97706"
+  },
+  semantic: {
+    success: "#15803d",
+    warning: "#b45309",
+    danger: "#b91c1c",
+    info: "#0369a1"
+  },
+  neutral: {
+    background: "#ffffff",
+    surface: "#f8fafc",
+    foreground: "#172033",
+    muted: "#64748b",
+    border: "#cbd5e1"
+  },
+  spacing: {
+    sm: "4px",
+    md: "8px",
+    lg: "16px"
+  },
+  radius: {
+    sm: "2px",
+    md: "4px",
+    lg: "6px"
+  }
+};
+var defaultDarkTheme = {
+  colorScheme: "dark",
+  brand: {
+    primary: "#60a5fa",
+    secondary: "#2dd4bf",
+    accent: "#fbbf24"
+  },
+  semantic: {
+    success: "#4ade80",
+    warning: "#fbbf24",
+    danger: "#f87171",
+    info: "#38bdf8"
+  },
+  neutral: {
+    background: "#111827",
+    surface: "#1f2937",
+    foreground: "#f8fafc",
+    muted: "#94a3b8",
+    border: "#334155"
+  },
+  spacing: {
+    sm: "4px",
+    md: "8px",
+    lg: "16px"
+  },
+  radius: {
+    sm: "2px",
+    md: "4px",
+    lg: "6px"
+  }
+};
+var appliedVariables = /* @__PURE__ */ new WeakMap();
+function createTheme(options = {}) {
+  const mode = state(options.defaultMode ?? "light");
+  const systemMode = state(readSystemMode());
+  const themes = state({
+    light: mergeThemes(defaultLightTheme, options.defaultTheme ?? {}, options.themes?.light ?? {}),
+    dark: mergeThemes(defaultDarkTheme, options.defaultTheme ?? {}, options.themes?.dark ?? {})
+  });
+  const overrides = state({});
+  const resolvedMode = memo(() => mode.value === "system" ? systemMode.value : mode.value);
+  const theme = memo(() => mergeThemes(themes.value[resolvedMode.value], overrides.value));
+  const brand = memo(() => {
+    const value = theme.value.brand;
+    return isThemeTokens(value) ? value : {};
+  });
+  let disposed = false;
+  let stopSystemListener;
+  if (typeof window !== "undefined" && typeof window.matchMedia === "function") {
+    const media = window.matchMedia("(prefers-color-scheme: dark)");
+    const listener = /* @__PURE__ */ __name((event) => {
+      systemMode.value = event.matches ? "dark" : "light";
+    }, "listener");
+    if (media.addEventListener) {
+      media.addEventListener("change", listener);
+      stopSystemListener = /* @__PURE__ */ __name(() => media.removeEventListener("change", listener), "stopSystemListener");
+    } else {
+      media.addListener(listener);
+      stopSystemListener = /* @__PURE__ */ __name(() => media.removeListener(listener), "stopSystemListener");
+    }
+  }
+  const context = {
+    theme,
+    brand,
+    mode,
+    resolvedMode,
+    dehydrate() {
+      ensureActive();
+      return { version: 1, mode: mode.value, overrides: overrides.value };
+    },
+    hydrate(snapshot) {
+      ensureActive();
+      const restored = parseDehydratedState(snapshot);
+      mode.value = restored.mode;
+      overrides.value = restored.overrides;
+    },
+    setTheme(nextTheme) {
+      ensureActive();
+      overrides.value = nextTheme;
+    },
+    setMode(nextMode) {
+      ensureActive();
+      mode.value = validateMode(nextMode);
+    },
+    setBrand(nextBrand) {
+      ensureActive();
+      overrides.value = mergeThemes(overrides.value, {
+        brand: {
+          ...brand.value,
+          ...nextBrand
+        }
+      });
+    },
+    registerTheme(nextMode, nextTheme) {
+      ensureActive();
+      const previous = themes.value[nextMode];
+      themes.value = {
+        ...themes.value,
+        [nextMode]: mergeThemes(previous, nextTheme)
+      };
+      return () => {
+        if (disposed) return;
+        themes.value = { ...themes.value, [nextMode]: previous };
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      stopSystemListener?.();
+      stopSystemListener = void 0;
+      theme.dispose();
+      brand.dispose();
+      resolvedMode.dispose();
+      mode.dispose();
+      systemMode.dispose();
+      themes.dispose();
+      overrides.dispose();
+    }
+  };
+  return context;
+  function ensureActive() {
+    if (disposed) throw new Error("Vobs Theme: \u5DF2\u9500\u6BC1\u7684\u4E0A\u4E0B\u6587\u4E0D\u80FD\u7EE7\u7EED\u4F7F\u7528");
+  }
+}
+__name(createTheme, "createTheme");
+function themePlugin(options = {}) {
+  return {
+    name: "@vobs/theme",
+    version: "0.1.0",
+    install(context) {
+      const ownedTheme = options.theme ? void 0 : createTheme(options);
+      const theme = options.theme ?? ownedTheme;
+      context.provide(THEME_KEY, theme);
+      return () => ownedTheme?.dispose();
+    }
+  };
+}
+__name(themePlugin, "themePlugin");
+function useTheme() {
+  const theme = inject(THEME_KEY);
+  if (!theme) throw new Error("Vobs Theme: \u627E\u4E0D\u5230\u4E0A\u4E0B\u6587\uFF0C\u8BF7\u5B89\u88C5 themePlugin");
+  return theme;
+}
+__name(useTheme, "useTheme");
+function ThemeBoundary(props = {}) {
+  const parent = useTheme();
+  const local = createScopedTheme(parent, mergeThemes(
+    props.theme ?? {},
+    props.tokens ?? {},
+    props.brand ? { brand: props.brand } : {}
+  ));
+  provide();
+  const root = createElement("div");
+  renderEffect(() => {
+    applyThemeVariables(root, local.theme.value);
+    root.dataset.vobsMode = local.resolvedMode.value;
+  });
+  const child = typeof props.children === "function" ? props.children() : props.children;
+  if (child) insertBefore(root, child, null);
+  return root;
+}
+__name(ThemeBoundary, "ThemeBoundary");
+function flattenTheme(theme) {
+  const variables = {};
+  flattenInto(theme, "", variables);
+  return variables;
+}
+__name(flattenTheme, "flattenTheme");
+function createScopedTheme(parent, initialOverrides) {
+  const overrides = state(initialOverrides);
+  const theme = memo(() => mergeThemes(parent.theme.value, overrides.value));
+  const brand = memo(() => {
+    const value = theme.value.brand;
+    return isThemeTokens(value) ? value : {};
+  });
+  let disposed = false;
+  const context = {
+    theme,
+    brand,
+    mode: parent.mode,
+    resolvedMode: parent.resolvedMode,
+    dehydrate: parent.dehydrate,
+    hydrate: parent.hydrate,
+    setTheme(nextTheme) {
+      ensureActive();
+      overrides.value = nextTheme;
+    },
+    setMode(nextMode) {
+      ensureActive();
+      parent.setMode(nextMode);
+    },
+    setBrand(nextBrand) {
+      ensureActive();
+      overrides.value = mergeThemes(overrides.value, {
+        brand: { ...brand.value, ...nextBrand }
+      });
+    },
+    registerTheme(nextMode, nextTheme) {
+      ensureActive();
+      return parent.registerTheme(nextMode, nextTheme);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      theme.dispose();
+      brand.dispose();
+      overrides.dispose();
+    }
+  };
+  return context;
+  function ensureActive() {
+    if (disposed) throw new Error("Vobs Theme: \u5DF2\u9500\u6BC1\u7684\u5C40\u90E8\u4E0A\u4E0B\u6587\u4E0D\u80FD\u7EE7\u7EED\u4F7F\u7528");
+  }
+}
+__name(createScopedTheme, "createScopedTheme");
+function parseDehydratedState(snapshot) {
+  let value = snapshot;
+  if (typeof snapshot === "string") {
+    try {
+      value = JSON.parse(snapshot);
+    } catch {
+      throw new Error("Vobs Theme: \u521D\u59CB\u72B6\u6001\u4E0D\u662F\u6709\u6548 JSON");
+    }
+  }
+  if (!value || typeof value !== "object") throw new Error("Vobs Theme: \u521D\u59CB\u72B6\u6001\u683C\u5F0F\u65E0\u6548");
+  const candidate = value;
+  if (candidate.version !== 1 || !candidate.overrides || typeof candidate.overrides !== "object") {
+    throw new Error("Vobs Theme: \u521D\u59CB\u72B6\u6001\u7248\u672C\u6216\u5B57\u6BB5\u65E0\u6548");
+  }
+  return {
+    version: 1,
+    mode: validateMode(candidate.mode),
+    overrides: candidate.overrides
+  };
+}
+__name(parseDehydratedState, "parseDehydratedState");
+function applyThemeVariables(root, theme) {
+  const next = flattenTheme(theme);
+  const previous = appliedVariables.get(root) ?? /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(next)) {
+    root.style.setProperty(key, value);
+    previous.delete(key);
+  }
+  for (const key of previous) root.style.removeProperty(key);
+  appliedVariables.set(root, new Set(Object.keys(next)));
+}
+__name(applyThemeVariables, "applyThemeVariables");
+function flattenInto(value, path, output) {
+  if (value === void 0) return;
+  if (isThemeTokens(value)) {
+    for (const [key, nested] of Object.entries(value)) {
+      const nextPath = key.startsWith("--") ? key : path ? `${path}-${key}` : key;
+      flattenInto(nested, nextPath, output);
+    }
+    return;
+  }
+  const variable = path.startsWith("--") ? path : `--vobs-${path}`;
+  output[variable] = String(value);
+}
+__name(flattenInto, "flattenInto");
+function mergeThemes(...themes) {
+  const result = {};
+  for (const theme of themes) {
+    for (const [key, value] of Object.entries(theme)) {
+      const previous = result[key];
+      result[key] = isThemeTokens(previous) && isThemeTokens(value) ? mergeThemes(previous, value) : value;
+    }
+  }
+  return result;
+}
+__name(mergeThemes, "mergeThemes");
+function isThemeTokens(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+__name(isThemeTokens, "isThemeTokens");
+function validateMode(mode) {
+  if (mode !== "light" && mode !== "dark" && mode !== "system") {
+    throw new Error("Vobs Theme: mode \u5FC5\u987B\u662F light\u3001dark \u6216 system");
+  }
+  return mode;
+}
+__name(validateMode, "validateMode");
+function readSystemMode() {
+  return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+__name(readSystemMode, "readSystemMode");
+
+exports.THEME_KEY = THEME_KEY;
+exports.ThemeBoundary = ThemeBoundary;
+exports.createTheme = createTheme;
+exports.defaultDarkTheme = defaultDarkTheme;
+exports.defaultLightTheme = defaultLightTheme;
+exports.flattenTheme = flattenTheme;
+exports.themePlugin = themePlugin;
+exports.useTheme = useTheme;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map