@fangxinyan/lumina 0.6.18 → 0.8.0

package/dist/chunk-EE5KXDRK.cjs

@@ -0,0 +1,1223 @@
+'use strict';
+
+require('./tokens-CEJVVA3G.css');
+var React3 = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React3__namespace = /*#__PURE__*/_interopNamespace(React3);
+
+// src/components/Theme/Theme.tsx
+var PortalContainerContext = React3__namespace.createContext(null);
+function PortalScopeProvider({ container, children }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(PortalContainerContext.Provider, { value: container, children });
+}
+function usePortalContainer() {
+  const scopedContainer = React3__namespace.useContext(PortalContainerContext);
+  if (scopedContainer) return scopedContainer;
+  if (typeof document === "undefined") return null;
+  return document.body;
+}
+var EMPTY_COMPONENT_OVERRIDES = Object.freeze({});
+var VisualThemeContext = React3__namespace.createContext(null);
+var ComponentOverridesContext = React3__namespace.createContext(
+  EMPTY_COMPONENT_OVERRIDES
+);
+var OwnerPortalThemeContext = React3__namespace.createContext(null);
+var imperativeThemeChangeListeners = /* @__PURE__ */ new Set();
+function subscribeImperativeThemeChange(listener) {
+  imperativeThemeChangeListeners.add(listener);
+  return () => imperativeThemeChangeListeners.delete(listener);
+}
+function notifyImperativeThemeChange(target) {
+  imperativeThemeChangeListeners.forEach((listener) => listener(target));
+}
+function mergeComponentOverride(parent, next) {
+  const styles = { ...parent?.styles ?? {} };
+  for (const [slot, style] of Object.entries(next.styles ?? {})) {
+    styles[slot] = { ...styles[slot] ?? {}, ...style };
+  }
+  return {
+    ...parent,
+    ...next,
+    colors: { ...parent?.colors ?? {}, ...next.colors ?? {} },
+    tokens: { ...parent?.tokens ?? {}, ...next.tokens ?? {} },
+    styles
+  };
+}
+function mergeComponentThemeOverrides(...sources) {
+  const result = {};
+  for (const source of sources) {
+    if (!source) continue;
+    for (const [name, override] of Object.entries(source)) {
+      if (!override) continue;
+      result[name] = mergeComponentOverride(result[name], override);
+    }
+  }
+  return result;
+}
+function VisualThemeProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(VisualThemeContext.Provider, { value, children });
+}
+function ComponentOverridesProvider({
+  value,
+  children
+}) {
+  const inherited = React3__namespace.useContext(ComponentOverridesContext);
+  const merged = React3__namespace.useMemo(() => {
+    if (!value || Object.keys(value).length === 0) return inherited;
+    return mergeComponentThemeOverrides(inherited, value);
+  }, [inherited, value]);
+  return /* @__PURE__ */ jsxRuntime.jsx(ComponentOverridesContext.Provider, { value: merged, children });
+}
+function OwnerPortalThemeProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(OwnerPortalThemeContext.Provider, { value, children });
+}
+function useVisualThemeSnapshot() {
+  return React3__namespace.useContext(VisualThemeContext);
+}
+function useComponentOverrides() {
+  return React3__namespace.useContext(ComponentOverridesContext);
+}
+function useOwnerPortalTheme() {
+  return React3__namespace.useContext(OwnerPortalThemeContext);
+}
+var ACCENT_PRESETS = {
+  sky: { accent: "oklch(68% 0.14 235)", ink: "oklch(42% 0.12 235)", soft: "oklch(92% 0.04 235)", glow: "oklch(68% 0.14 235 / 0.35)" },
+  coral: { accent: "oklch(72% 0.16 35)", ink: "oklch(48% 0.14 35)", soft: "oklch(94% 0.04 35)", glow: "oklch(72% 0.16 35 / 0.35)" },
+  mint: { accent: "oklch(72% 0.13 165)", ink: "oklch(46% 0.11 165)", soft: "oklch(93% 0.04 165)", glow: "oklch(72% 0.13 165 / 0.35)" },
+  violet: { accent: "oklch(66% 0.16 290)", ink: "oklch(44% 0.14 290)", soft: "oklch(93% 0.04 290)", glow: "oklch(66% 0.16 290 / 0.35)" },
+  amber: { accent: "oklch(76% 0.14 75)", ink: "oklch(50% 0.12 75)", soft: "oklch(94% 0.05 75)", glow: "oklch(76% 0.14 75 / 0.35)" },
+  rose: { accent: "oklch(68% 0.17 10)", ink: "oklch(46% 0.15 10)", soft: "oklch(93% 0.04 10)", glow: "oklch(68% 0.17 10 / 0.35)" }
+};
+var ACCENT_PRESETS_DARK = {
+  sky: { soft: "oklch(35% 0.08 235)", ink: "oklch(82% 0.10 235)", glow: "oklch(68% 0.14 235 / 0.18)" },
+  coral: { soft: "oklch(38% 0.09 35)", ink: "oklch(84% 0.10 35)", glow: "oklch(72% 0.16 35 / 0.18)" },
+  mint: { soft: "oklch(36% 0.08 165)", ink: "oklch(83% 0.10 165)", glow: "oklch(72% 0.13 165 / 0.18)" },
+  violet: { soft: "oklch(36% 0.09 290)", ink: "oklch(82% 0.11 290)", glow: "oklch(66% 0.16 290 / 0.18)" },
+  amber: { soft: "oklch(38% 0.08 75)", ink: "oklch(85% 0.10 75)", glow: "oklch(76% 0.14 75 / 0.18)" },
+  rose: { soft: "oklch(38% 0.09 10)", ink: "oklch(84% 0.11 10)", glow: "oklch(68% 0.17 10 / 0.18)" }
+};
+var FONT_STACKS = {
+  system: '-apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif',
+  sf: '"SF Pro Display", -apple-system, BlinkMacSystemFont, "PingFang SC", sans-serif',
+  serif: 'Cambria, Georgia, "Songti SC", "STSong", serif',
+  mono: 'ui-monospace, "SF Mono", "JetBrains Mono", Consolas, monospace'
+};
+var DEFAULT_CONFIG = {
+  mode: "light",
+  colorScheme: "light",
+  baseColor: void 0,
+  accent: "sky",
+  density: "comfortable",
+  intensity: 5,
+  radius: 20,
+  font: "sf",
+  colors: {},
+  tokens: {},
+  components: {},
+  themes: {},
+  accentExplicit: false
+};
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var useIsomorphicLayoutEffect = isBrowser ? React3__namespace.useLayoutEffect : React3__namespace.useEffect;
+function isThemeBaseMode(mode) {
+  return mode === "light" || mode === "dark";
+}
+function isBuiltInThemeMode(mode) {
+  return mode === "light" || mode === "dark" || mode === "system";
+}
+var TRANSIENT_THEME_MODES = /* @__PURE__ */ new Set(["__theme_panel_draft__"]);
+function isTransientThemeMode(mode) {
+  return mode != null && TRANSIENT_THEME_MODES.has(mode);
+}
+function getThemePreset(themes, mode) {
+  if (!mode || isBuiltInThemeMode(mode)) return void 0;
+  return themes?.[mode];
+}
+function isThemePresetValueEqual(current, preset) {
+  if (current === preset) return true;
+  if (current == null || preset == null || typeof current !== "object" || typeof preset !== "object") {
+    return false;
+  }
+  return JSON.stringify(current) === JSON.stringify(preset);
+}
+function clearActiveThemePreset(config) {
+  const preset = getThemePreset(config.themes, config.mode);
+  if (!preset) return config;
+  const next = { ...config };
+  const presetFields = [
+    ["colorScheme", preset.base],
+    ["baseColor", preset.baseColor],
+    ["accent", preset.accent],
+    ["density", preset.density],
+    ["intensity", preset.intensity],
+    ["radius", preset.radius],
+    ["font", preset.font],
+    ["colors", preset.colors],
+    ["tokens", preset.tokens],
+    [
+      "components",
+      preset.components ? mergeComponentThemeOverrides(void 0, preset.components) : void 0
+    ]
+  ];
+  for (const [key, presetValue] of presetFields) {
+    if (presetValue !== void 0 && isThemePresetValueEqual(next[key], presetValue)) {
+      delete next[key];
+    }
+  }
+  return next;
+}
+function applyThemePreset(config, mode) {
+  const base = clearActiveThemePreset(config);
+  const preset = getThemePreset(base.themes, mode);
+  if (!preset) {
+    return {
+      ...base,
+      mode,
+      colorScheme: isThemeBaseMode(mode) ? mode : base.colorScheme
+    };
+  }
+  return {
+    ...base,
+    mode,
+    colorScheme: preset.base ?? base.colorScheme ?? DEFAULT_CONFIG.colorScheme,
+    baseColor: preset.baseColor ?? base.baseColor,
+    accent: preset.accent ?? base.accent,
+    density: preset.density ?? base.density,
+    intensity: preset.intensity ?? base.intensity,
+    radius: preset.radius ?? base.radius,
+    font: preset.font ?? base.font,
+    colors: preset.colors ? { ...preset.colors } : base.colors,
+    tokens: preset.tokens ? { ...preset.tokens } : base.tokens,
+    components: preset.components ? mergeComponentThemeOverrides(void 0, preset.components) : base.components
+  };
+}
+function patchThemeConfig(current, patch) {
+  const themesChanged = Object.prototype.hasOwnProperty.call(patch, "themes");
+  const modeChanged = Object.prototype.hasOwnProperty.call(patch, "mode");
+  let base = themesChanged ? clearActiveThemePreset(current) : current;
+  if (themesChanged) {
+    base = { ...base, themes: patch.themes };
+  }
+  const mode = modeChanged ? patch.mode : base.mode;
+  const withMode = (modeChanged || themesChanged) && mode !== void 0 ? applyThemePreset(base, mode) : base;
+  return { ...withMode, ...patch };
+}
+function resolveThemeConfig(config) {
+  const mode = config.mode ?? DEFAULT_CONFIG.mode;
+  const themes = config.themes ?? DEFAULT_CONFIG.themes;
+  const preset = getThemePreset(themes, mode);
+  const accentExplicit = config.accent !== void 0 || preset?.accent !== void 0;
+  const presetConfig = preset ? {
+    ...preset.base ? { colorScheme: preset.base } : null,
+    ...preset.baseColor ? { baseColor: preset.baseColor } : null,
+    ...preset.accent ? { accent: preset.accent } : null,
+    ...preset.density ? { density: preset.density } : null,
+    ...preset.intensity != null ? { intensity: preset.intensity } : null,
+    ...preset.radius != null ? { radius: preset.radius } : null,
+    ...preset.font ? { font: preset.font } : null
+  } : {};
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...presetConfig,
+    ...config,
+    mode,
+    themes,
+    colors: {
+      ...preset?.colors ?? {},
+      ...config.colors ?? {}
+    },
+    components: mergeComponentThemeOverrides(preset?.components, config.components),
+    tokens: {
+      ...preset?.tokens ?? {},
+      ...config.tokens ?? {}
+    }
+  };
+  return {
+    ...merged,
+    colorScheme: merged.colorScheme ?? preset?.base ?? DEFAULT_CONFIG.colorScheme,
+    baseColor: merged.baseColor ?? preset?.baseColor,
+    accent: merged.accent ?? preset?.accent ?? DEFAULT_CONFIG.accent,
+    density: merged.density ?? preset?.density ?? DEFAULT_CONFIG.density,
+    intensity: merged.intensity ?? preset?.intensity ?? DEFAULT_CONFIG.intensity,
+    radius: merged.radius ?? preset?.radius ?? DEFAULT_CONFIG.radius,
+    font: merged.font ?? preset?.font ?? DEFAULT_CONFIG.font,
+    accentExplicit
+  };
+}
+function resolveThemeMode(mode) {
+  if (mode !== "system") return mode;
+  if (!isBrowser) return "light";
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function resolveThemeColorScheme(mode, themes, fallback) {
+  if (mode === "system") return fallback ?? resolveThemeMode(mode);
+  if (isThemeBaseMode(mode)) return mode;
+  return getThemePreset(themes, mode)?.base ?? fallback ?? DEFAULT_CONFIG.colorScheme;
+}
+function normalizeAccentInput(input, colorScheme) {
+  if (typeof input === "string" && input in ACCENT_PRESETS) {
+    const key = input;
+    const base = ACCENT_PRESETS[key];
+    if (colorScheme === "dark") {
+      return { key, palette: { ...base, ...ACCENT_PRESETS_DARK[key] } };
+    }
+    return { key, palette: base };
+  }
+  const raw = typeof input === "string" ? { accent: input } : input;
+  const { accent } = raw;
+  const ink = raw.ink ?? `color-mix(in oklch, ${accent} 65%, black)`;
+  const soft = raw.soft ?? (colorScheme === "dark" ? `color-mix(in oklch, ${accent} 30%, black)` : `color-mix(in oklch, ${accent} 15%, white)`);
+  const glow = raw.glow ?? (colorScheme === "dark" ? `color-mix(in oklch, ${accent} 18%, transparent)` : `color-mix(in oklch, ${accent} 35%, transparent)`);
+  return { key: "custom", palette: { accent, ink, soft, glow } };
+}
+var DEFAULT_THEME_COLORS = {
+  light: {
+    bg: "#e8eef5",
+    bgRaised: "#edf2f8",
+    bgSunken: "#dde4ed",
+    fg: "#3a4558",
+    fgMuted: "#7b8599",
+    fgSubtle: "#9ca7ba",
+    border: "rgba(130, 148, 175, 0.14)",
+    divider: "rgba(130, 148, 175, 0.18)",
+    shadowDark: "rgba(163, 177, 198, 0.55)",
+    shadowLight: "rgba(255, 255, 255, 0.95)",
+    accent: ACCENT_PRESETS.sky.accent,
+    accentInk: ACCENT_PRESETS.sky.ink,
+    accentSoft: ACCENT_PRESETS.sky.soft,
+    accentGlow: ACCENT_PRESETS.sky.glow,
+    info: "oklch(68% 0.14 235)",
+    success: "oklch(68% 0.14 150)",
+    warning: "oklch(75% 0.14 75)",
+    danger: "oklch(64% 0.18 25)"
+  },
+  dark: {
+    bg: "#1b2030",
+    bgRaised: "#242a3c",
+    bgSunken: "#151a27",
+    fg: "#d8deeb",
+    fgMuted: "#8b94ab",
+    fgSubtle: "#5f6a82",
+    border: "rgba(0, 0, 0, 0.35)",
+    divider: "rgba(255, 255, 255, 0.06)",
+    shadowDark: "rgba(0, 0, 0, 0.55)",
+    shadowLight: "rgba(130, 145, 180, 0.06)",
+    accent: ACCENT_PRESETS.sky.accent,
+    accentInk: ACCENT_PRESETS_DARK.sky.ink,
+    accentSoft: ACCENT_PRESETS_DARK.sky.soft,
+    accentGlow: ACCENT_PRESETS_DARK.sky.glow,
+    info: "oklch(78% 0.12 235)",
+    success: "oklch(78% 0.14 150)",
+    warning: "oklch(82% 0.14 75)",
+    danger: "oklch(76% 0.16 25)"
+  }
+};
+function mixColor(value, percent, other) {
+  return `color-mix(in srgb, ${value} ${percent}%, ${other})`;
+}
+function fadeColor(value, percent) {
+  return `color-mix(in srgb, ${value} ${percent}%, transparent)`;
+}
+function deriveThemeColors(baseColor, options = {}) {
+  const colorScheme = options.colorScheme ?? "light";
+  const dark = colorScheme === "dark";
+  const derivedAccent = dark ? mixColor(baseColor, 68, "white") : mixColor(baseColor, 62, "black");
+  const explicitAccent = options.accent ? normalizeAccentInput(options.accent, colorScheme).palette : null;
+  const accent = explicitAccent?.accent ?? derivedAccent;
+  return {
+    bg: baseColor,
+    bgRaised: mixColor(baseColor, dark ? 86 : 82, "white"),
+    bgSunken: mixColor(baseColor, dark ? 80 : 86, "black"),
+    fg: mixColor(baseColor, 18, dark ? "white" : "black"),
+    fgMuted: mixColor(baseColor, 38, dark ? "white" : "black"),
+    fgSubtle: mixColor(baseColor, 55, dark ? "white" : "black"),
+    border: mixColor(baseColor, 82, dark ? "white" : "black"),
+    divider: mixColor(baseColor, 88, dark ? "white" : "black"),
+    shadowDark: fadeColor(
+      mixColor(baseColor, dark ? 40 : 58, "black"),
+      dark ? 65 : 55
+    ),
+    shadowLight: fadeColor(
+      mixColor(baseColor, dark ? 82 : 28, "white"),
+      dark ? 22 : 88
+    ),
+    accent,
+    accentInk: explicitAccent?.ink ?? mixColor(accent, 65, dark ? "white" : "black"),
+    accentSoft: explicitAccent?.soft ?? mixColor(accent, dark ? 30 : 15, dark ? "black" : "white"),
+    accentGlow: explicitAccent?.glow ?? fadeColor(accent, dark ? 25 : 40)
+  };
+}
+var COLOR_TOKEN_KEYS = {
+  bg: "bg",
+  bgRaised: "bg-raised",
+  bgSunken: "bg-sunken",
+  fg: "fg",
+  fgMuted: "fg-muted",
+  fgSubtle: "fg-subtle",
+  border: "border",
+  divider: "divider",
+  shadowDark: "shadow-dark",
+  shadowLight: "shadow-light",
+  accent: "accent",
+  accentInk: "accent-ink",
+  accentSoft: "accent-soft",
+  accentGlow: "accent-glow",
+  info: "info",
+  success: "success",
+  warning: "warning",
+  danger: "danger"
+};
+function hasAccentColorOverride(config) {
+  return ["accent", "accentInk", "accentSoft", "accentGlow"].some((key) => {
+    const tokenKey = COLOR_TOKEN_KEYS[key];
+    return config.colors?.[key] !== void 0 || config.tokens?.[tokenKey] !== void 0 || config.tokens?.[`--${tokenKey}`] !== void 0;
+  });
+}
+function resolveThemeColors(config, colorScheme, inherited) {
+  const fallback = inherited ?? DEFAULT_THEME_COLORS[colorScheme];
+  const surface = config.baseColor ? deriveThemeColors(config.baseColor, { colorScheme, accent: config.accent }) : { ...fallback };
+  if (!config.baseColor && config.accent) {
+    const palette = normalizeAccentInput(config.accent, colorScheme).palette;
+    surface.accent = palette.accent;
+    surface.accentInk = palette.ink;
+    surface.accentSoft = palette.soft;
+    surface.accentGlow = palette.glow;
+  }
+  const resolved = {
+    ...fallback,
+    ...surface,
+    ...config.colors ?? {}
+  };
+  for (const [colorKey, tokenKey] of Object.entries(COLOR_TOKEN_KEYS)) {
+    const value = config.tokens?.[tokenKey] ?? config.tokens?.[`--${tokenKey}`];
+    if (value !== void 0) resolved[colorKey] = value;
+  }
+  return resolved;
+}
+function themeColorsToStyle(colors, prefix = "") {
+  const style = {};
+  for (const [colorKey, tokenKey] of Object.entries(COLOR_TOKEN_KEYS)) {
+    style[`--${prefix}${tokenKey}`] = colors[colorKey];
+  }
+  return style;
+}
+function themeTokenToKebabCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+function visualThemeToStyle(snapshot, prefix = "") {
+  const style = themeColorsToStyle(snapshot.colors, prefix);
+  const variable = (name) => `--${prefix}${name}`;
+  const reference = (name) => `var(${variable(name)})`;
+  const inheritedReference = (name) => prefix ? `var(${variable(name)}, var(--${name}))` : `var(--${name})`;
+  const d = 0.4 + snapshot.intensity * 0.12;
+  const dark = snapshot.colorScheme === "dark";
+  style[variable("d")] = String(d);
+  style[variable("shadow-offset")] = `calc(${dark ? 4 : 6}px * ${reference("d")} * ${inheritedReference("shadow-scale")})`;
+  style[variable("shadow-blur")] = `calc(${dark ? 10 : 16}px * ${reference("d")} * ${inheritedReference("shadow-scale")})`;
+  style[variable("shadow-inset-offset")] = `calc(${dark ? 3 : 4}px * ${reference("d")} * ${inheritedReference("shadow-scale")})`;
+  style[variable("shadow-inset-blur")] = `calc(${dark ? 7 : 10}px * ${reference("d")} * ${inheritedReference("shadow-scale")})`;
+  style[variable("neu-shadow-panel")] = `${reference("shadow-offset")} ${reference("shadow-offset")} ${reference("shadow-blur")} ${reference("shadow-dark")}, calc(${reference("shadow-offset")} * -1) calc(${reference("shadow-offset")} * -1) ${reference("shadow-blur")} ${reference("shadow-light")}`;
+  style[variable("neu-shadow-control")] = `calc(${reference("shadow-offset")} * .5) calc(${reference("shadow-offset")} * .5) calc(${reference("shadow-blur")} * .6) ${reference("shadow-dark")}, calc(${reference("shadow-offset")} * -.5) calc(${reference("shadow-offset")} * -.5) calc(${reference("shadow-blur")} * .6) ${reference("shadow-light")}`;
+  style[variable("neu-shadow-lift")] = `calc(${reference("shadow-offset")} * 1.6) calc(${reference("shadow-offset")} * 1.6) calc(${reference("shadow-blur")} * 1.4) ${reference("shadow-dark")}, calc(${reference("shadow-offset")} * -1.6) calc(${reference("shadow-offset")} * -1.6) calc(${reference("shadow-blur")} * 1.4) ${reference("shadow-light")}`;
+  style[variable("neu-shadow-inset-strong")] = `inset ${reference("shadow-inset-offset")} ${reference("shadow-inset-offset")} ${reference("shadow-inset-blur")} ${reference("shadow-dark")}, inset calc(${reference("shadow-inset-offset")} * -1) calc(${reference("shadow-inset-offset")} * -1) ${reference("shadow-inset-blur")} ${reference("shadow-light")}`;
+  style[variable("neu-shadow-inset")] = `inset calc(${reference("shadow-inset-offset")} * .6) calc(${reference("shadow-inset-offset")} * .6) calc(${reference("shadow-inset-blur")} * .6) ${reference("shadow-dark")}, inset calc(${reference("shadow-inset-offset")} * -.6) calc(${reference("shadow-inset-offset")} * -.6) calc(${reference("shadow-inset-blur")} * .6) ${reference("shadow-light")}`;
+  style[variable("neu-shadow-subtle")] = `1px 1px 2px ${reference("shadow-dark")}, -1px -1px 2px ${reference("shadow-light")}`;
+  style[variable("neu-shadow-float")] = `0 calc(${reference("shadow-offset")} * 1.8 * ${inheritedReference("shadow-float-scale")}) calc(${reference("shadow-blur")} * 2.2 * ${inheritedReference("shadow-float-scale")}) ${reference("shadow-dark")}, 0 calc(${reference("shadow-offset")} * .4 * ${inheritedReference("shadow-float-scale")}) calc(${reference("shadow-blur")} * .7 * ${inheritedReference("shadow-float-scale")}) ${reference("shadow-dark")}`;
+  style[variable("neu-out")] = reference("neu-shadow-panel");
+  style[variable("neu-out-sm")] = reference("neu-shadow-control");
+  style[variable("neu-out-lg")] = reference("neu-shadow-lift");
+  style[variable("neu-in")] = reference("neu-shadow-inset-strong");
+  style[variable("neu-in-sm")] = reference("neu-shadow-inset");
+  style[variable("neu-flat")] = reference("neu-shadow-subtle");
+  style[variable("neu-float")] = reference("neu-shadow-float");
+  return style;
+}
+function componentTokensToStyle(tokens, prefix) {
+  if (!tokens) return {};
+  const style = {};
+  for (const [key, value] of Object.entries(tokens)) {
+    const property = key.startsWith("--") ? key : `--${prefix}${themeTokenToKebabCase(key)}`;
+    style[property] = value;
+  }
+  return style;
+}
+function resolveVisualThemeSnapshot(config, inherited) {
+  const colorScheme = config.colorScheme ?? inherited?.colorScheme ?? "light";
+  const inheritedColors = inherited?.colorScheme === colorScheme ? inherited.colors : DEFAULT_THEME_COLORS[colorScheme];
+  return {
+    colorScheme,
+    intensity: config.intensity ?? inherited?.intensity ?? DEFAULT_CONFIG.intensity,
+    colors: resolveThemeColors(config, colorScheme, inheritedColors)
+  };
+}
+function toVar(key) {
+  return key.startsWith("--") ? key : `--${key}`;
+}
+var LEGACY_SHADOW_TOKEN_ALIASES = {
+  "--neu-flat": "--neu-shadow-subtle",
+  "--neu-out-sm": "--neu-shadow-control",
+  "--neu-out": "--neu-shadow-panel",
+  "--neu-out-lg": "--neu-shadow-lift",
+  "--neu-in-sm": "--neu-shadow-inset",
+  "--neu-in": "--neu-shadow-inset-strong",
+  "--neu-float": "--neu-shadow-float"
+};
+function resolvedThemeConfigToStyle(config, snapshot) {
+  const style = { ...visualThemeToStyle(snapshot) };
+  const radius = config.radius ?? DEFAULT_CONFIG.radius;
+  style["--r-xs"] = `${Math.max(4, radius - 16)}px`;
+  style["--r-sm"] = `${Math.max(6, radius - 12)}px`;
+  style["--r-md"] = `${Math.max(8, radius - 6)}px`;
+  style["--r-lg"] = `${radius}px`;
+  style["--r-xl"] = `${radius + 10}px`;
+  const font = config.font ?? DEFAULT_CONFIG.font;
+  if (typeof font === "string") {
+    style["--font-sans"] = FONT_STACKS[font] ?? font;
+    if (font === "mono") style["--font-display"] = FONT_STACKS.mono;
+  } else {
+    if (font.sans) style["--font-sans"] = font.sans;
+    if (font.display) style["--font-display"] = font.display;
+    if (font.mono) style["--font-mono"] = font.mono;
+  }
+  const tokenVars = new Set(Object.keys(config.tokens).map(toVar));
+  for (const [key, value] of Object.entries(config.tokens)) {
+    const variable = toVar(key);
+    const semanticAlias = LEGACY_SHADOW_TOKEN_ALIASES[variable];
+    if (semanticAlias && !tokenVars.has(semanticAlias)) {
+      style[semanticAlias] = value;
+    }
+    style[variable] = value;
+  }
+  return style;
+}
+function resolvedThemeConfigToDataAttributes(config, colorScheme) {
+  const accentResult = normalizeAccentInput(config.accent, colorScheme);
+  const hidesAccent = config.baseColor && !config.accentExplicit || accentResult.key === "custom" || hasAccentColorOverride(config);
+  return {
+    "data-theme": colorScheme,
+    "data-theme-mode": config.mode,
+    "data-density": config.density,
+    "data-accent": hidesAccent ? void 0 : accentResult.key
+  };
+}
+var imperativeThemeStyleKeys = /* @__PURE__ */ new WeakMap();
+var ROOT_THEME_ATTRIBUTES = [
+  "data-theme",
+  "data-theme-mode",
+  "data-density",
+  "data-accent"
+];
+function createRootThemeMutationState(target) {
+  const previousImperativeStyleKeys = imperativeThemeStyleKeys.get(target);
+  const styles = /* @__PURE__ */ new Map();
+  previousImperativeStyleKeys?.forEach((property) => {
+    styles.set(property, {
+      value: target.style.getPropertyValue(property),
+      priority: target.style.getPropertyPriority(property)
+    });
+  });
+  return {
+    target,
+    attributes: new Map(
+      ROOT_THEME_ATTRIBUTES.map((attribute) => [attribute, target.getAttribute(attribute)])
+    ),
+    styles,
+    activeStyleKeys: /* @__PURE__ */ new Set(),
+    previousImperativeStyleKeys: previousImperativeStyleKeys ? new Set(previousImperativeStyleKeys) : void 0
+  };
+}
+function restoreRootThemeStyleProperty(state, property) {
+  const snapshot = state.styles.get(property);
+  if (!snapshot || snapshot.value === "") {
+    state.target.style.removeProperty(property);
+    return;
+  }
+  state.target.style.setProperty(property, snapshot.value, snapshot.priority);
+}
+function applyProviderThemeToRoot(state, config, style) {
+  const nextStyleKeys = new Set(Object.keys(style));
+  for (const property of nextStyleKeys) {
+    if (state.styles.has(property)) continue;
+    state.styles.set(property, {
+      value: state.target.style.getPropertyValue(property),
+      priority: state.target.style.getPropertyPriority(property)
+    });
+  }
+  const removedStyleKeys = [...state.activeStyleKeys].filter(
+    (property) => !nextStyleKeys.has(property)
+  );
+  applyTheme(state.target, config);
+  removedStyleKeys.forEach((property) => restoreRootThemeStyleProperty(state, property));
+  state.activeStyleKeys = nextStyleKeys;
+}
+function restoreRootThemeMutationState(state) {
+  state.styles.forEach((_snapshot, property) => {
+    restoreRootThemeStyleProperty(state, property);
+  });
+  state.attributes.forEach((value, attribute) => {
+    if (value === null) state.target.removeAttribute(attribute);
+    else state.target.setAttribute(attribute, value);
+  });
+  if (state.previousImperativeStyleKeys) {
+    imperativeThemeStyleKeys.set(state.target, state.previousImperativeStyleKeys);
+  } else {
+    imperativeThemeStyleKeys.delete(state.target);
+  }
+  notifyImperativeThemeChange(state.target);
+}
+function applyTheme(target, config) {
+  const cfg = resolveThemeConfig(config);
+  const colorScheme = resolveThemeColorScheme(cfg.mode, cfg.themes, cfg.colorScheme);
+  const snapshot = resolveVisualThemeSnapshot({
+    baseColor: cfg.baseColor,
+    colorScheme,
+    accent: cfg.accentExplicit ? cfg.accent : void 0,
+    intensity: cfg.intensity,
+    colors: cfg.colors,
+    tokens: cfg.tokens
+  });
+  const dataAttributes = resolvedThemeConfigToDataAttributes(cfg, colorScheme);
+  for (const [attribute, value] of Object.entries(dataAttributes)) {
+    if (value === void 0) target.removeAttribute(attribute);
+    else target.setAttribute(attribute, value);
+  }
+  const style = resolvedThemeConfigToStyle(cfg, snapshot);
+  const nextStyleKeys = new Set(Object.keys(style));
+  for (const property of imperativeThemeStyleKeys.get(target) ?? []) {
+    if (!nextStyleKeys.has(property)) target.style.removeProperty(property);
+  }
+  for (const [property, value] of Object.entries(style)) {
+    target.style.setProperty(property, value);
+  }
+  imperativeThemeStyleKeys.set(target, nextStyleKeys);
+  notifyImperativeThemeChange(target);
+}
+var ThemeCtx = React3__namespace.createContext(null);
+var ThemeInheritanceCtx = React3__namespace.createContext(void 0);
+function useTheme() {
+  const ctx = React3__namespace.useContext(ThemeCtx);
+  if (!ctx) {
+    throw new Error(
+      "useTheme() must be used inside <ThemeProvider>. Wrap your app (or a subtree) with <ThemeProvider>."
+    );
+  }
+  return ctx;
+}
+function useThemeOptional() {
+  return React3__namespace.useContext(ThemeCtx);
+}
+function mergeThemeConfigs(inherited, local) {
+  const merged = { ...inherited ?? {} };
+  const themes = { ...inherited?.themes ?? {}, ...local.themes ?? {} };
+  const mode = local.mode ?? inherited?.mode;
+  const localDefinesActivePreset = mode !== void 0 && local.themes !== void 0 && Object.prototype.hasOwnProperty.call(local.themes, mode);
+  const preset = mode !== void 0 && (local.mode !== void 0 || localDefinesActivePreset) ? getThemePreset(themes, mode) : void 0;
+  if (mode !== void 0) merged.mode = mode;
+  if (local.mode !== void 0 && isThemeBaseMode(mode)) {
+    merged.colorScheme = mode;
+  }
+  if (preset) {
+    if (preset.base !== void 0) merged.colorScheme = preset.base;
+    if (preset.baseColor !== void 0) merged.baseColor = preset.baseColor;
+    if (preset.accent !== void 0) merged.accent = preset.accent;
+    if (preset.density !== void 0) merged.density = preset.density;
+    if (preset.intensity !== void 0) merged.intensity = preset.intensity;
+    if (preset.radius !== void 0) merged.radius = preset.radius;
+    if (preset.font !== void 0) merged.font = preset.font;
+  }
+  const scalarKeys = [
+    "mode",
+    "colorScheme",
+    "baseColor",
+    "accent",
+    "density",
+    "intensity",
+    "radius",
+    "font"
+  ];
+  for (const key of scalarKeys) {
+    const value = local[key];
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  if ((local.baseColor !== void 0 || preset?.baseColor !== void 0) && local.accent === void 0 && preset?.accent === void 0) {
+    delete merged.accent;
+  }
+  const inheritedColors = { ...inherited?.colors ?? {} };
+  const inheritedTokens = { ...inherited?.tokens ?? {} };
+  const resetColorKeys = /* @__PURE__ */ new Set();
+  if (local.baseColor !== void 0 || preset?.baseColor !== void 0) {
+    for (const key of Object.keys(COLOR_TOKEN_KEYS)) {
+      resetColorKeys.add(key);
+    }
+  } else {
+    for (const key of [
+      ...Object.keys(preset?.colors ?? {}),
+      ...Object.keys(local.colors ?? {})
+    ]) {
+      resetColorKeys.add(key);
+    }
+    if (local.accent !== void 0 || preset?.accent !== void 0) {
+      resetColorKeys.add("accent");
+      resetColorKeys.add("accentInk");
+      resetColorKeys.add("accentSoft");
+      resetColorKeys.add("accentGlow");
+    }
+  }
+  for (const key of resetColorKeys) {
+    delete inheritedColors[key];
+    const tokenKey = COLOR_TOKEN_KEYS[key];
+    delete inheritedTokens[tokenKey];
+    delete inheritedTokens[`--${tokenKey}`];
+  }
+  merged.colors = {
+    ...inheritedColors,
+    ...preset?.colors ?? {},
+    ...local.colors ?? {}
+  };
+  merged.tokens = {
+    ...inheritedTokens,
+    ...preset?.tokens ?? {},
+    ...local.tokens ?? {}
+  };
+  merged.components = mergeComponentThemeOverrides(
+    inherited?.components,
+    preset?.components,
+    local.components
+  );
+  merged.themes = themes;
+  return merged;
+}
+var THEME_STORAGE_VERSION = 1;
+function isPersistedThemeEnvelope(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.version === "number" && !!candidate.config && typeof candidate.config === "object";
+}
+function loadPersisted(key) {
+  if (!key || !isBrowser) return null;
+  try {
+    const raw = localStorage.getItem(key);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    const persisted = isPersistedThemeEnvelope(parsed) ? parsed.config : parsed;
+    if (isTransientThemeMode(persisted.mode)) {
+      localStorage.removeItem(key);
+      return null;
+    }
+    return persisted;
+  } catch {
+    return null;
+  }
+}
+function persist(key, cfg) {
+  if (!key || !isBrowser) return;
+  if (isTransientThemeMode(cfg.mode)) return;
+  try {
+    const payload = {
+      version: THEME_STORAGE_VERSION,
+      config: cfg
+    };
+    localStorage.setItem(key, JSON.stringify(payload));
+  } catch {
+  }
+}
+function applyExplicitThemeProps(base, props) {
+  return {
+    ...base,
+    ...props.mode !== void 0 ? { mode: props.mode } : null,
+    ...props.colorScheme !== void 0 ? { colorScheme: props.colorScheme } : null,
+    ...props.baseColor !== void 0 ? { baseColor: props.baseColor } : null,
+    ...props.accent !== void 0 ? { accent: props.accent } : null,
+    ...props.density !== void 0 ? { density: props.density } : null,
+    ...props.intensity !== void 0 ? { intensity: props.intensity } : null,
+    ...props.radius !== void 0 ? { radius: props.radius } : null,
+    ...props.font !== void 0 ? { font: props.font } : null,
+    ...props.colors !== void 0 ? { colors: props.colors } : null,
+    ...props.tokens !== void 0 ? { tokens: props.tokens } : null,
+    ...props.components !== void 0 ? { components: props.components } : null,
+    ...props.themes !== void 0 ? { themes: props.themes } : null
+  };
+}
+function createThemeConfigFromProps(props, includeDefaults = true) {
+  if (!includeDefaults) {
+    return applyExplicitThemeProps({}, props);
+  }
+  const mode = props.mode ?? DEFAULT_CONFIG.mode;
+  const fromProps = {
+    mode,
+    colorScheme: props.colorScheme,
+    baseColor: props.baseColor,
+    accent: props.accent,
+    density: props.density ?? DEFAULT_CONFIG.density,
+    intensity: props.intensity ?? DEFAULT_CONFIG.intensity,
+    radius: props.radius ?? DEFAULT_CONFIG.radius,
+    font: props.font ?? DEFAULT_CONFIG.font,
+    colors: props.colors ?? {},
+    tokens: props.tokens ?? {},
+    components: props.components ?? {},
+    themes: props.themes ?? DEFAULT_CONFIG.themes
+  };
+  return applyExplicitThemeProps(applyThemePreset(fromProps, mode), props);
+}
+function mergeThemeScopeRefs(internalRef, childRef) {
+  return (node) => {
+    internalRef.current = node;
+    if (typeof childRef === "function") childRef(node);
+    else if (childRef) {
+      childRef.current = node;
+    }
+  };
+}
+var ThemeProvider = (props) => {
+  const {
+    children,
+    enabled = true,
+    target = "root",
+    as: Tag = "div",
+    asChild = false,
+    className,
+    style,
+    storageKey,
+    onChange,
+    ...configProps
+  } = props;
+  const inheritedConfig = React3__namespace.useContext(ThemeInheritanceCtx);
+  const inheritedThemeValue = React3__namespace.useContext(ThemeCtx);
+  const inheritedVisualSnapshot = useVisualThemeSnapshot();
+  const inheritedPortalContainer = usePortalContainer();
+  const hasInheritedTheme = inheritedConfig !== void 0;
+  const initialConfig = React3__namespace.useMemo(() => {
+    const fromProps = createThemeConfigFromProps(configProps, !hasInheritedTheme);
+    const persisted = loadPersisted(storageKey);
+    const withExplicitProps = fromProps;
+    if (!persisted) return withExplicitProps;
+    let persistedForMerge = persisted;
+    if (configProps.themes !== void 0) {
+      const { themes: _persistedThemes, ...rest } = persisted;
+      persistedForMerge = rest;
+    }
+    const persistedMode = persistedForMerge.mode ?? withExplicitProps.mode;
+    const presetBase = persistedMode === void 0 ? withExplicitProps : applyThemePreset(
+      { ...withExplicitProps, mode: persistedMode },
+      persistedMode
+    );
+    const withPersisted = {
+      ...presetBase,
+      ...persistedForMerge,
+      ...configProps.themes !== void 0 ? { themes: configProps.themes } : null
+    };
+    const withControlledThemePreset = configProps.themes !== void 0 && persistedMode !== void 0 && !isBuiltInThemeMode(persistedMode) ? applyThemePreset(withPersisted, persistedMode) : withPersisted;
+    return applyExplicitThemeProps(withControlledThemePreset, configProps);
+  }, []);
+  const [config, setConfig] = React3__namespace.useState(initialConfig);
+  const previousPropsRef = React3__namespace.useRef({
+    mode: configProps.mode,
+    colorScheme: configProps.colorScheme,
+    baseColor: configProps.baseColor,
+    accent: configProps.accent,
+    density: configProps.density,
+    intensity: configProps.intensity,
+    radius: configProps.radius,
+    font: configProps.font,
+    colors: configProps.colors,
+    tokens: configProps.tokens,
+    components: configProps.components,
+    themes: configProps.themes
+  });
+  React3__namespace.useEffect(() => {
+    const previous = previousPropsRef.current;
+    const changedProps = {};
+    const assignIfChanged = (key, value2) => {
+      if (value2 !== previous[key]) changedProps[key] = value2;
+    };
+    assignIfChanged("mode", configProps.mode);
+    assignIfChanged("colorScheme", configProps.colorScheme);
+    assignIfChanged("baseColor", configProps.baseColor);
+    assignIfChanged("accent", configProps.accent);
+    assignIfChanged("density", configProps.density);
+    assignIfChanged("intensity", configProps.intensity);
+    assignIfChanged("radius", configProps.radius);
+    assignIfChanged("font", configProps.font);
+    assignIfChanged("colors", configProps.colors);
+    assignIfChanged("tokens", configProps.tokens);
+    assignIfChanged("components", configProps.components);
+    assignIfChanged("themes", configProps.themes);
+    previousPropsRef.current = {
+      mode: configProps.mode,
+      colorScheme: configProps.colorScheme,
+      baseColor: configProps.baseColor,
+      accent: configProps.accent,
+      density: configProps.density,
+      intensity: configProps.intensity,
+      radius: configProps.radius,
+      font: configProps.font,
+      colors: configProps.colors,
+      tokens: configProps.tokens,
+      components: configProps.components,
+      themes: configProps.themes
+    };
+    if (Object.keys(changedProps).length === 0) return;
+    setConfig((c) => {
+      const currentBase = Object.prototype.hasOwnProperty.call(changedProps, "themes") ? clearActiveThemePreset(c) : c;
+      const base = {
+        ...currentBase,
+        ...Object.prototype.hasOwnProperty.call(changedProps, "themes") ? { themes: configProps.themes ?? DEFAULT_CONFIG.themes } : null
+      };
+      const fallbackMode = hasInheritedTheme ? void 0 : DEFAULT_CONFIG.mode;
+      const mode = Object.prototype.hasOwnProperty.call(changedProps, "mode") ? configProps.mode ?? fallbackMode : c.mode ?? fallbackMode;
+      const shouldApplyPreset = mode !== void 0 && (Object.prototype.hasOwnProperty.call(changedProps, "mode") || Object.prototype.hasOwnProperty.call(changedProps, "themes") && !isBuiltInThemeMode(mode));
+      const shouldUseProp = (key) => Object.prototype.hasOwnProperty.call(changedProps, key) || configProps[key] !== void 0;
+      const nextFromMode = shouldApplyPreset ? applyThemePreset(base, mode) : base;
+      const next = {
+        ...nextFromMode,
+        mode,
+        ...shouldUseProp("colorScheme") ? { colorScheme: configProps.colorScheme } : null,
+        ...shouldUseProp("baseColor") ? { baseColor: configProps.baseColor } : null,
+        ...shouldUseProp("accent") ? { accent: configProps.accent } : null,
+        ...shouldUseProp("density") ? { density: configProps.density } : null,
+        ...shouldUseProp("intensity") ? { intensity: configProps.intensity } : null,
+        ...shouldUseProp("radius") ? { radius: configProps.radius } : null,
+        ...shouldUseProp("font") ? { font: configProps.font } : null,
+        ...shouldUseProp("colors") ? { colors: configProps.colors } : null,
+        ...shouldUseProp("tokens") ? { tokens: configProps.tokens } : null,
+        ...shouldUseProp("components") ? { components: configProps.components } : null
+      };
+      if (next.mode === c.mode && next.colorScheme === c.colorScheme && next.baseColor === c.baseColor && next.accent === c.accent && next.density === c.density && next.intensity === c.intensity && next.radius === c.radius && next.font === c.font && next.colors === c.colors && next.tokens === c.tokens && next.components === c.components && next.themes === c.themes) {
+        return c;
+      }
+      return next;
+    });
+  }, [
+    configProps.mode,
+    configProps.colorScheme,
+    configProps.baseColor,
+    configProps.accent,
+    configProps.density,
+    configProps.intensity,
+    configProps.radius,
+    configProps.font,
+    configProps.colors,
+    configProps.tokens,
+    configProps.components,
+    configProps.themes,
+    hasInheritedTheme
+  ]);
+  React3__namespace.useEffect(() => {
+    if (!storageKey || !isBrowser) return;
+    const handleStorage = (event) => {
+      if (event.key !== storageKey && event.key !== null) return;
+      if (event.newValue === null) {
+        setConfig(createThemeConfigFromProps(configProps, !hasInheritedTheme));
+        return;
+      }
+      const persisted = loadPersisted(storageKey);
+      if (!persisted) return;
+      setConfig((current) => {
+        const persistedForMerge = { ...persisted };
+        if (configProps.themes !== void 0) delete persistedForMerge.themes;
+        const mode = configProps.mode ?? persistedForMerge.mode ?? current.mode ?? (hasInheritedTheme ? void 0 : DEFAULT_CONFIG.mode);
+        const persistedConfig = {
+          ...current,
+          ...persistedForMerge,
+          ...configProps.themes !== void 0 ? { themes: configProps.themes } : null
+        };
+        const merged = mode === void 0 ? persistedConfig : applyThemePreset(persistedConfig, mode);
+        return applyExplicitThemeProps({
+          ...merged,
+          ...mode !== void 0 ? { mode } : null
+        }, configProps);
+      });
+    };
+    window.addEventListener("storage", handleStorage);
+    return () => window.removeEventListener("storage", handleStorage);
+  }, [
+    configProps.mode,
+    configProps.colorScheme,
+    configProps.baseColor,
+    configProps.accent,
+    configProps.density,
+    configProps.intensity,
+    configProps.radius,
+    configProps.font,
+    configProps.colors,
+    configProps.tokens,
+    configProps.components,
+    configProps.themes,
+    hasInheritedTheme,
+    storageKey
+  ]);
+  const [systemDark, setSystemDark] = React3__namespace.useState(
+    () => isBrowser && window.matchMedia("(prefers-color-scheme: dark)").matches
+  );
+  React3__namespace.useEffect(() => {
+    if (!isBrowser) return;
+    const mql = window.matchMedia("(prefers-color-scheme: dark)");
+    const handler = (e) => setSystemDark(e.matches);
+    mql.addEventListener?.("change", handler);
+    return () => mql.removeEventListener?.("change", handler);
+  }, []);
+  const effectiveConfig = React3__namespace.useMemo(
+    () => resolveThemeConfig(mergeThemeConfigs(inheritedConfig, config)),
+    [config, inheritedConfig]
+  );
+  const activeTheme = React3__namespace.useMemo(
+    () => getThemePreset(effectiveConfig.themes, effectiveConfig.mode) ?? null,
+    [effectiveConfig.mode, effectiveConfig.themes]
+  );
+  const colorScheme = effectiveConfig.mode === "system" ? systemDark ? "dark" : "light" : isThemeBaseMode(effectiveConfig.mode) ? effectiveConfig.mode : effectiveConfig.colorScheme ?? activeTheme?.base ?? DEFAULT_CONFIG.colorScheme;
+  const resolvedMode = effectiveConfig.mode === "system" ? colorScheme : effectiveConfig.mode;
+  const visualSnapshot = React3__namespace.useMemo(
+    () => resolveVisualThemeSnapshot({
+      baseColor: effectiveConfig.baseColor,
+      colorScheme,
+      accent: effectiveConfig.accentExplicit ? effectiveConfig.accent : void 0,
+      intensity: effectiveConfig.intensity,
+      colors: effectiveConfig.colors,
+      tokens: effectiveConfig.tokens
+    }),
+    [
+      effectiveConfig.baseColor,
+      effectiveConfig.accent,
+      effectiveConfig.accentExplicit,
+      effectiveConfig.intensity,
+      effectiveConfig.colors,
+      effectiveConfig.tokens,
+      colorScheme
+    ]
+  );
+  const { key: accentKey, palette: accentPalette } = React3__namespace.useMemo(() => {
+    if (effectiveConfig.baseColor && !effectiveConfig.accentExplicit || hasAccentColorOverride(effectiveConfig)) {
+      return {
+        key: "custom",
+        palette: {
+          accent: visualSnapshot.colors.accent,
+          ink: visualSnapshot.colors.accentInk,
+          soft: visualSnapshot.colors.accentSoft,
+          glow: visualSnapshot.colors.accentGlow
+        }
+      };
+    }
+    return normalizeAccentInput(effectiveConfig.accent, colorScheme);
+  }, [
+    effectiveConfig.baseColor,
+    effectiveConfig.accent,
+    effectiveConfig.accentExplicit,
+    colorScheme,
+    visualSnapshot.colors
+  ]);
+  const scopeRef = React3__namespace.useRef(null);
+  const scopeChild = target === "scope" && asChild ? React3__namespace.Children.only(children) : null;
+  const scopeChildRef = scopeChild?.ref;
+  const mergedScopeRef = React3__namespace.useMemo(
+    () => mergeThemeScopeRefs(scopeRef, scopeChildRef),
+    [scopeChildRef]
+  );
+  const [portalContainer, setPortalContainer] = React3__namespace.useState(null);
+  const rootThemeMutationRef = React3__namespace.useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    if (!isBrowser || !enabled || target !== "scope") {
+      setPortalContainer(null);
+      return;
+    }
+    const container = document.createElement("div");
+    container.dataset.luminaPortalScope = "";
+    container.style.display = "contents";
+    document.body.appendChild(container);
+    setPortalContainer(container);
+    return () => {
+      container.remove();
+    };
+  }, [enabled, target]);
+  useIsomorphicLayoutEffect(() => {
+    if (!isBrowser || !enabled || target !== "root") return;
+    const state = createRootThemeMutationState(document.documentElement);
+    rootThemeMutationRef.current = state;
+    return () => {
+      if (rootThemeMutationRef.current !== state) return;
+      restoreRootThemeMutationState(state);
+      rootThemeMutationRef.current = null;
+    };
+  }, [enabled, target]);
+  useIsomorphicLayoutEffect(() => {
+    if (!isBrowser || !enabled) return;
+    const targets = (target === "root" ? [document.documentElement] : [portalContainer]).filter((element) => element != null);
+    if (targets.length === 0) return;
+    for (const el of targets) {
+      const resolvedConfig = {
+        ...effectiveConfig,
+        accent: effectiveConfig.accentExplicit ? effectiveConfig.accent : void 0,
+        colorScheme
+      };
+      if (target === "root" && rootThemeMutationRef.current?.target === el) {
+        applyProviderThemeToRoot(
+          rootThemeMutationRef.current,
+          resolvedConfig,
+          resolvedThemeConfigToStyle(effectiveConfig, visualSnapshot)
+        );
+      } else {
+        applyTheme(el, resolvedConfig);
+      }
+    }
+    persist(storageKey, config);
+  }, [
+    colorScheme,
+    config,
+    effectiveConfig,
+    enabled,
+    portalContainer,
+    storageKey,
+    target
+  ]);
+  const value = React3__namespace.useMemo(() => {
+    const patch = (p) => setConfig((c) => patchThemeConfig(c, p));
+    return {
+      mode: effectiveConfig.mode,
+      resolvedMode,
+      colorScheme,
+      baseColor: effectiveConfig.baseColor,
+      accent: accentKey,
+      accentPalette,
+      density: effectiveConfig.density,
+      intensity: effectiveConfig.intensity,
+      radius: effectiveConfig.radius,
+      font: effectiveConfig.font,
+      colors: effectiveConfig.colors,
+      tokens: effectiveConfig.tokens,
+      themes: effectiveConfig.themes,
+      components: effectiveConfig.components,
+      activeTheme,
+      setMode: (m) => patch({ mode: m }),
+      toggleMode: () => setConfig((currentConfig) => {
+        const currentMode = currentConfig.mode ?? effectiveConfig.mode;
+        return patchThemeConfig(currentConfig, {
+          mode: currentMode === "dark" ? "light" : "dark"
+        });
+      }),
+      setBaseColor: (baseColor) => patch({ baseColor }),
+      setAccent: (a) => patch({ accent: a }),
+      setDensity: (d) => patch({ density: d }),
+      setIntensity: (n) => patch({ intensity: n }),
+      setRadius: (n) => patch({ radius: n }),
+      setFont: (f) => patch({ font: f }),
+      setColors: (colors) => patch({ colors }),
+      setTokens: (t) => patch({ tokens: t }),
+      setThemes: (t) => patch({ themes: t }),
+      setComponents: (components) => patch({ components }),
+      update: patch,
+      reset: () => setConfig(initialConfig)
+    };
+  }, [effectiveConfig, resolvedMode, colorScheme, accentKey, accentPalette, activeTheme, initialConfig]);
+  const inheritanceConfig = React3__namespace.useMemo(() => ({
+    mode: effectiveConfig.mode,
+    colorScheme,
+    baseColor: effectiveConfig.baseColor,
+    ...effectiveConfig.accentExplicit ? { accent: effectiveConfig.accent } : null,
+    density: effectiveConfig.density,
+    intensity: effectiveConfig.intensity,
+    radius: effectiveConfig.radius,
+    font: effectiveConfig.font,
+    colors: effectiveConfig.colors,
+    tokens: effectiveConfig.tokens,
+    components: effectiveConfig.components,
+    themes: effectiveConfig.themes
+  }), [effectiveConfig, colorScheme]);
+  const onChangeRef = React3__namespace.useRef(onChange);
+  onChangeRef.current = onChange;
+  React3__namespace.useEffect(() => {
+    if (!enabled) return;
+    onChangeRef.current?.(value);
+  }, [enabled, value]);
+  const activePortalContainer = enabled ? target === "scope" ? portalContainer : null : inheritedPortalContainer;
+  const activeVisualSnapshot = enabled ? visualSnapshot : inheritedVisualSnapshot;
+  const activeComponentOverrides = enabled ? effectiveConfig.components : void 0;
+  const activeInheritanceConfig = enabled ? inheritanceConfig : inheritedConfig;
+  const activeThemeValue = enabled ? value : inheritedThemeValue;
+  if (target === "scope") {
+    const Component = Tag;
+    const scopeThemeStyle = enabled ? {
+      color: "var(--fg)",
+      fontFamily: "var(--font-sans)",
+      ...resolvedThemeConfigToStyle(effectiveConfig, visualSnapshot)
+    } : {};
+    const scopeDataAttributes = enabled ? resolvedThemeConfigToDataAttributes(effectiveConfig, colorScheme) : {};
+    const scopeNode = asChild && scopeChild ? React3__namespace.cloneElement(scopeChild, {
+      ...scopeDataAttributes,
+      ref: mergedScopeRef,
+      className: [className, scopeChild.props.className].filter(Boolean).join(" ") || void 0,
+      style: {
+        ...scopeThemeStyle,
+        ...style,
+        ...scopeChild.props.style
+      }
+    }) : /* @__PURE__ */ jsxRuntime.jsx(
+      Component,
+      {
+        ref: scopeRef,
+        className,
+        ...scopeDataAttributes,
+        style: {
+          ...scopeThemeStyle,
+          ...style
+        },
+        children
+      }
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(PortalScopeProvider, { container: activePortalContainer, children: /* @__PURE__ */ jsxRuntime.jsx(VisualThemeProvider, { value: activeVisualSnapshot, children: /* @__PURE__ */ jsxRuntime.jsx(ComponentOverridesProvider, { value: activeComponentOverrides, children: /* @__PURE__ */ jsxRuntime.jsx(ThemeInheritanceCtx.Provider, { value: activeInheritanceConfig, children: /* @__PURE__ */ jsxRuntime.jsx(ThemeCtx.Provider, { value: activeThemeValue, children: scopeNode }) }) }) }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(PortalScopeProvider, { container: activePortalContainer, children: /* @__PURE__ */ jsxRuntime.jsx(VisualThemeProvider, { value: activeVisualSnapshot, children: /* @__PURE__ */ jsxRuntime.jsx(ComponentOverridesProvider, { value: activeComponentOverrides, children: /* @__PURE__ */ jsxRuntime.jsx(ThemeInheritanceCtx.Provider, { value: activeInheritanceConfig, children: /* @__PURE__ */ jsxRuntime.jsx(ThemeCtx.Provider, { value: activeThemeValue, children }) }) }) }) });
+};
+
+exports.ACCENT_PRESETS = ACCENT_PRESETS;
+exports.ACCENT_PRESETS_DARK = ACCENT_PRESETS_DARK;
+exports.ComponentOverridesProvider = ComponentOverridesProvider;
+exports.DEFAULT_THEME_COLORS = DEFAULT_THEME_COLORS;
+exports.FONT_STACKS = FONT_STACKS;
+exports.OwnerPortalThemeProvider = OwnerPortalThemeProvider;
+exports.ThemeProvider = ThemeProvider;
+exports.VisualThemeProvider = VisualThemeProvider;
+exports.applyTheme = applyTheme;
+exports.componentTokensToStyle = componentTokensToStyle;
+exports.deriveThemeColors = deriveThemeColors;
+exports.mergeComponentThemeOverrides = mergeComponentThemeOverrides;
+exports.normalizeAccentInput = normalizeAccentInput;
+exports.resolveThemeColorScheme = resolveThemeColorScheme;
+exports.resolveThemeColors = resolveThemeColors;
+exports.resolveThemeMode = resolveThemeMode;
+exports.resolveVisualThemeSnapshot = resolveVisualThemeSnapshot;
+exports.subscribeImperativeThemeChange = subscribeImperativeThemeChange;
+exports.themeColorsToStyle = themeColorsToStyle;
+exports.themeTokenToKebabCase = themeTokenToKebabCase;
+exports.useComponentOverrides = useComponentOverrides;
+exports.useOwnerPortalTheme = useOwnerPortalTheme;
+exports.usePortalContainer = usePortalContainer;
+exports.useTheme = useTheme;
+exports.useThemeOptional = useThemeOptional;
+exports.useVisualThemeSnapshot = useVisualThemeSnapshot;
+exports.visualThemeToStyle = visualThemeToStyle;