@tenerife.music/ui 1.0.8 → 1.0.12

package/dist/theme/index.mjs

@@ -1,9 +1,122 @@
-"use client";
-import { m as fe, p as ge, b as he, s as xe, c as q, d as V, e as Q, f as G, g as J } from "../motion-CzQhSEqk.js";
-import { h as nr, a as sr } from "../motion-CzQhSEqk.js";
-import { jsx as be } from "react/jsx-runtime";
-import p from "react";
-const we = {
+import React from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/themes/brand.ts
+var brand_exports = {};
+__export(brand_exports, {
+  brandTheme: () => brandTheme
+});
+var brandTheme;
+var init_brand = __esm({
+  "src/themes/brand.ts"() {
+    brandTheme = {
+      name: "brand",
+      description: "Brand-specific theme with custom color palette",
+      // Override primary colors - warmer blue tones for brand
+      primaryColors: {
+        500: "210 75% 45%",
+        // Brighter, warmer blue
+        600: "210 70% 40%",
+        700: "210 65% 35%"
+      },
+      // Override accent colors - vibrant purple-pink gradient
+      accentColors: {
+        400: "285 75% 65%",
+        // Softer purple
+        500: "285 80% 60%",
+        // Vibrant purple-pink
+        600: "285 75% 55%"
+      },
+      // Override secondary colors - teal accent for brand
+      secondaryColors: {
+        400: "170 85% 50%",
+        // Brighter teal
+        500: "170 90% 45%",
+        // Vibrant teal (#00d9b8)
+        600: "170 85% 40%"
+      },
+      // Override semantic colors for day mode - brand-aligned colors
+      semanticColorsDay: {
+        success: "145 75% 40%",
+        // Brand-aligned green
+        info: "210 75% 50%"
+        // Brand primary blue
+      },
+      // Override semantic colors for night mode
+      semanticColorsNight: {
+        success: "145 70% 48%",
+        // Brighter brand green
+        info: "210 75% 55%"
+        // Brighter brand blue
+      }
+    };
+  }
+});
+
+// src/themes/dark.ts
+var dark_exports = {};
+__export(dark_exports, {
+  darkTheme: () => darkTheme
+});
+var darkTheme;
+var init_dark = __esm({
+  "src/themes/dark.ts"() {
+    darkTheme = {
+      name: "dark",
+      description: "Enhanced dark theme with deeper surfaces and higher contrast",
+      // Override surface colors for night mode - darker backgrounds
+      surfaceColorsNight: {
+        base: "240 10% 2%",
+        // Even darker base (#050508)
+        elevated1: "240 10% 3%",
+        // #08080a
+        elevated2: "240 10% 4%",
+        // #0a0a0c
+        elevated3: "240 10% 5%",
+        // #0c0c0e
+        overlay: "0 0% 0% / 0.85",
+        // Darker overlay for better contrast
+        glass: "240 10% 5% / 0.95"
+        // More opaque glass effect
+      },
+      // Override base colors for night mode - deeper backgrounds
+      baseColorsNight: {
+        background: "240 10% 2%",
+        // Match surface base
+        card: "240 10% 2%",
+        popover: "240 10% 3%"
+      }
+    };
+  }
+});
+
+// src/themes/default.ts
+var default_exports = {};
+__export(default_exports, {
+  defaultTheme: () => defaultTheme
+});
+var defaultTheme;
+var init_default = __esm({
+  "src/themes/default.ts"() {
+    defaultTheme = {
+      name: "default",
+      description: "Default Tenerife UI theme with standard color palette"
+    };
+  }
+});
+
+// src/themes/minimal.ts
+var minimalBrand = {
   id: "minimal",
   name: "Minimal",
   description: "Clean, minimal brand theme with muted colors, light typography, and compact spacing",
@@ -347,7 +460,10 @@ const we = {
       }
     }
   ]
-}, $e = {
+};
+
+// src/themes/neon.ts
+var neonBrand = {
   id: "neon",
   name: "Neon",
   description: "Vibrant brand theme with high-saturation neon colors, bold typography, and enhanced visual effects",
@@ -698,396 +814,1218 @@ const we = {
       }
     }
   ]
-}, v = /* @__PURE__ */ new Map();
-let F = null, M = null;
-const j = /* @__PURE__ */ new Map();
-function oe(r) {
-  const e = [], s = [];
-  if (!r || typeof r != "object")
+};
+
+// src/themes/brand_engine.ts
+var brandRegistry = /* @__PURE__ */ new Map();
+var activeBrand = null;
+var activeNamespace = null;
+var brandCache = /* @__PURE__ */ new Map();
+function validateBrand(brand) {
+  const errors = [];
+  const warnings = [];
+  if (!brand || typeof brand !== "object") {
     return {
-      valid: !1,
+      valid: false,
       errors: ["Brand must be an object"],
       warnings: []
     };
-  const t = r, n = ["id", "name", "namespace"];
-  for (const o of n)
-    (!(o in t) || !t[o]) && e.push(`Missing required field: ${o}`);
-  if (t.id && typeof t.id == "string" && (/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(t.id) || e.push(
-    `Invalid brand ID format: "${t.id}". Must be kebab-case (e.g., "neon-brand")`
-  )), t.namespace && typeof t.namespace == "string" && (/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(t.namespace) || e.push(
-    `Invalid namespace format: "${t.namespace}". Must be kebab-case (e.g., "neon")`
-  )), t.themes)
-    if (!Array.isArray(t.themes))
-      e.push("Brand themes must be an array");
-    else {
-      const o = t.themes;
-      o.length === 0 && s.push("Brand has no themes defined"), o.forEach((m, i) => {
-        if (!m || typeof m != "object") {
-          e.push(`Theme at index ${i} must be an object`);
+  }
+  const brandObj = brand;
+  const requiredFields = ["id", "name", "namespace"];
+  for (const field of requiredFields) {
+    if (!(field in brandObj) || !brandObj[field]) {
+      errors.push(`Missing required field: ${field}`);
+    }
+  }
+  if (brandObj.id && typeof brandObj.id === "string") {
+    const idRegex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+    if (!idRegex.test(brandObj.id)) {
+      errors.push(
+        `Invalid brand ID format: "${brandObj.id}". Must be kebab-case (e.g., "neon-brand")`
+      );
+    }
+  }
+  if (brandObj.namespace && typeof brandObj.namespace === "string") {
+    const namespaceRegex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+    if (!namespaceRegex.test(brandObj.namespace)) {
+      errors.push(
+        `Invalid namespace format: "${brandObj.namespace}". Must be kebab-case (e.g., "neon")`
+      );
+    }
+  }
+  if (brandObj.themes) {
+    if (!Array.isArray(brandObj.themes)) {
+      errors.push("Brand themes must be an array");
+    } else {
+      const themes2 = brandObj.themes;
+      if (themes2.length === 0) {
+        warnings.push("Brand has no themes defined");
+      }
+      themes2.forEach((theme, index) => {
+        if (!theme || typeof theme !== "object") {
+          errors.push(`Theme at index ${index} must be an object`);
           return;
         }
-        const a = m;
-        (!a.id || typeof a.id != "string") && e.push(`Theme at index ${i} is missing required field: id`), (!a.name || typeof a.name != "string") && e.push(`Theme at index ${i} is missing required field: name`), (!a.mode || !["day", "night"].includes(a.mode)) && e.push(`Theme at index ${i} must have mode set to "day" or "night"`), (!a.overrides || typeof a.overrides != "object") && e.push(`Theme at index ${i} is missing required field: overrides`);
+        const themeObj = theme;
+        if (!themeObj.id || typeof themeObj.id !== "string") {
+          errors.push(`Theme at index ${index} is missing required field: id`);
+        }
+        if (!themeObj.name || typeof themeObj.name !== "string") {
+          errors.push(`Theme at index ${index} is missing required field: name`);
+        }
+        if (!themeObj.mode || !["day", "night"].includes(themeObj.mode)) {
+          errors.push(`Theme at index ${index} must have mode set to "day" or "night"`);
+        }
+        if (!themeObj.overrides || typeof themeObj.overrides !== "object") {
+          errors.push(`Theme at index ${index} is missing required field: overrides`);
+        }
       });
     }
-  else
-    e.push("Brand must have at least one theme");
-  if (t.version && typeof t.version == "string" && (/^\d+\.\d+\.\d+$/.test(t.version) || s.push(
-    `Invalid version format: "${t.version}". Should be semver (e.g., "1.0.0")`
-  )), t.themes && Array.isArray(t.themes)) {
-    const o = t.themes.map(
-      (i) => i == null ? void 0 : i.id
-    ), m = new Set(o);
-    o.length !== m.size && e.push("Brand contains duplicate theme IDs");
+  } else {
+    errors.push("Brand must have at least one theme");
+  }
+  if (brandObj.version && typeof brandObj.version === "string") {
+    const semverRegex = /^\d+\.\d+\.\d+$/;
+    if (!semverRegex.test(brandObj.version)) {
+      warnings.push(
+        `Invalid version format: "${brandObj.version}". Should be semver (e.g., "1.0.0")`
+      );
+    }
+  }
+  if (brandObj.themes && Array.isArray(brandObj.themes)) {
+    const themeIds = brandObj.themes.map(
+      (theme) => theme?.id
+    );
+    const uniqueIds = new Set(themeIds);
+    if (themeIds.length !== uniqueIds.size) {
+      errors.push("Brand contains duplicate theme IDs");
+    }
   }
   return {
-    valid: e.length === 0,
-    errors: e,
-    warnings: s
+    valid: errors.length === 0,
+    errors,
+    warnings
   };
 }
-function X(r, e) {
-  const s = oe(r);
-  if (!s.valid)
-    throw new Error(`Invalid brand "${r.id}": ${s.errors.join(", ")}`);
-  s.warnings.length > 0 && console.warn(`Brand "${r.id}" validation warnings:`, s.warnings.join(", "));
-  const t = v.get(r.id);
-  if (t && t.brand.namespace === r.namespace)
+function registerBrand(brand, options) {
+  const validation = validateBrand(brand);
+  if (!validation.valid) {
+    throw new Error(`Invalid brand "${brand.id}": ${validation.errors.join(", ")}`);
+  }
+  if (validation.warnings.length > 0) {
+    console.warn(`Brand "${brand.id}" validation warnings:`, validation.warnings.join(", "));
+  }
+  const existingEntry = brandRegistry.get(brand.id);
+  if (existingEntry && existingEntry.brand.namespace === brand.namespace) {
     return;
-  if (v.has(r.id))
-    throw new Error(`Brand "${r.id}" is already registered`);
-  const n = Array.from(v.values()).find(
-    (o) => o.brand.namespace === r.namespace
+  }
+  if (brandRegistry.has(brand.id)) {
+    throw new Error(`Brand "${brand.id}" is already registered`);
+  }
+  const existingBrand = Array.from(brandRegistry.values()).find(
+    (entry) => entry.brand.namespace === brand.namespace
   );
-  if (n)
+  if (existingBrand) {
     throw new Error(
-      `Brand namespace "${r.namespace}" is already used by brand "${n.brand.id}"`
+      `Brand namespace "${brand.namespace}" is already used by brand "${existingBrand.brand.id}"`
     );
-  v.set(r.id, {
-    brand: r,
-    enabled: (e == null ? void 0 : e.enabled) !== !1,
-    loader: e == null ? void 0 : e.loader
+  }
+  brandRegistry.set(brand.id, {
+    brand,
+    enabled: options?.enabled !== false,
+    loader: options?.loader
   });
 }
-async function ne(r) {
-  if (j.has(r))
-    return j.get(r);
-  const e = v.get(r);
-  if (!e)
-    throw new Error(`Brand "${r}" not found in registry`);
-  if (e.enabled === !1)
-    throw new Error(`Brand "${r}" is disabled`);
-  if (e.loader)
+async function loadBrand(brandId) {
+  if (brandCache.has(brandId)) {
+    return brandCache.get(brandId);
+  }
+  const entry = brandRegistry.get(brandId);
+  if (!entry) {
+    throw new Error(`Brand "${brandId}" not found in registry`);
+  }
+  if (entry.enabled === false) {
+    throw new Error(`Brand "${brandId}" is disabled`);
+  }
+  if (entry.loader) {
     try {
-      const t = (await e.loader()).default, n = oe(t);
-      if (!n.valid)
-        throw new Error(`Invalid loaded brand "${r}": ${n.errors.join(", ")}`);
-      return j.set(r, t), t;
-    } catch (s) {
+      const module = await entry.loader();
+      const loadedBrand = module.default;
+      const validation = validateBrand(loadedBrand);
+      if (!validation.valid) {
+        throw new Error(`Invalid loaded brand "${brandId}": ${validation.errors.join(", ")}`);
+      }
+      brandCache.set(brandId, loadedBrand);
+      return loadedBrand;
+    } catch (error) {
       throw new Error(
-        `Failed to load brand "${r}": ${s instanceof Error ? s.message : String(s)}`
+        `Failed to load brand "${brandId}": ${error instanceof Error ? error.message : String(error)}`
       );
     }
-  return j.set(r, e.brand), e.brand;
+  }
+  brandCache.set(brandId, entry.brand);
+  return entry.brand;
 }
-function se() {
-  return F;
+function getActiveBrand() {
+  return activeBrand;
 }
-function O(r) {
-  F = r, M = (r == null ? void 0 : r.namespace) || null;
+function setActiveBrand(brand) {
+  activeBrand = brand;
+  activeNamespace = brand?.namespace || null;
 }
-function Pe() {
-  F = null, M = null;
+function clearActiveBrand() {
+  activeBrand = null;
+  activeNamespace = null;
 }
-function ve(r, e) {
-  return r.themes.find((s) => s.mode === e);
+function getBrandTheme(brand, mode) {
+  return brand.themes.find((theme) => theme.mode === mode);
 }
-function ae(r, e) {
-  if (typeof document > "u") return;
-  const s = ve(r, e);
-  if (!s) {
-    console.warn(`Brand "${r.id}" has no theme for mode "${e}"`);
+function applyBrandOverrides(brand, mode) {
+  if (typeof document === "undefined") return;
+  const theme = getBrandTheme(brand, mode);
+  if (!theme) {
+    console.warn(`Brand "${brand.id}" has no theme for mode "${mode}"`);
     return;
   }
-  const t = document.documentElement, { namespace: n } = r, { overrides: o } = s;
-  o.primaryColors && Object.entries(o.primaryColors).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-primary-${i}`, a);
-  }), o.accentColors && Object.entries(o.accentColors).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-accent-${i}`, a);
-  }), o.secondaryColors && Object.entries(o.secondaryColors).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-secondary-${i}`, a);
-  });
-  const m = e === "day" ? o.baseColorsDay : o.baseColorsNight;
-  if (m && Object.entries(m).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-${i}`, a);
-  }), o.typography && (o.typography.fontFamily && Object.entries(o.typography.fontFamily).forEach(([i, a]) => {
-    t.style.setProperty(
-      `--brand-${n}-font-${i}`,
-      Array.isArray(a) ? a.join(", ") : a
-    );
-  }), o.typography.fontSize && Object.entries(o.typography.fontSize).forEach(([i, a]) => {
-    const c = typeof a == "string" ? a : a[0];
-    t.style.setProperty(`--brand-${n}-font-size-${i}`, c);
-  }), o.typography.fontWeight && Object.entries(o.typography.fontWeight).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-font-weight-${i}`, a);
-  }), o.typography.lineHeight && Object.entries(o.typography.lineHeight).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-line-height-${i}`, a);
-  }), o.typography.letterSpacing && Object.entries(o.typography.letterSpacing).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-letter-spacing-${i}`, a);
-  })), o.spacing && (o.spacing.semanticSpacing && Object.entries(o.spacing.semanticSpacing).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-spacing-${i}`, a);
-  }), o.spacing.layoutSpacing)) {
-    const i = o.spacing.layoutSpacing;
-    i.section && Object.entries(i.section).forEach(([a, c]) => {
-      typeof c == "string" && t.style.setProperty(`--brand-${n}-layout-section-${a}`, c);
-    }), i.container && Object.entries(i.container).forEach(([a, c]) => {
-      typeof c == "string" && t.style.setProperty(`--brand-${n}-layout-container-${a}`, c);
-    }), i.grid && Object.entries(i.grid).forEach(([a, c]) => {
-      typeof c == "string" && t.style.setProperty(`--brand-${n}-layout-grid-${a}`, c);
-    }), i.stack && Object.entries(i.stack).forEach(([a, c]) => {
-      typeof c == "string" && t.style.setProperty(`--brand-${n}-layout-stack-${a}`, c);
-    }), i.component && Object.entries(i.component).forEach(([a, c]) => {
-      typeof c == "string" && t.style.setProperty(`--brand-${n}-layout-component-${a}`, c);
+  const root = document.documentElement;
+  const { namespace } = brand;
+  const { overrides } = theme;
+  if (overrides.primaryColors) {
+    Object.entries(overrides.primaryColors).forEach(([key, value]) => {
+      root.style.setProperty(`--brand-${namespace}-primary-${key}`, value);
     });
   }
-  if (o.shadows && (o.shadows.elevationShadows && Object.entries(o.shadows.elevationShadows).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-shadow-${i}`, a);
-  }), o.shadows.primaryColoredShadows && Object.entries(o.shadows.primaryColoredShadows).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-shadow-primary-${i}`, a);
-  }), o.shadows.accentColoredShadows && Object.entries(o.shadows.accentColoredShadows).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-shadow-accent-${i}`, a);
-  }), o.shadows.glowEffects && Object.entries(o.shadows.glowEffects).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-glow-${i}`, a);
-  }), o.shadows.focusRings && Object.entries(o.shadows.focusRings).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-focus-ring-${i}`, a);
-  })), o.radius && (o.radius.borderRadius && Object.entries(o.radius.borderRadius).forEach(([i, a]) => {
-    t.style.setProperty(`--brand-${n}-radius-${i}`, a);
-  }), o.radius.componentRadius)) {
-    const { componentRadius: i } = o.radius;
-    i.button && Object.entries(i.button).forEach(([a, c]) => {
-      t.style.setProperty(`--brand-${n}-radius-button-${a}`, c);
-    }), i.card && Object.entries(i.card).forEach(([a, c]) => {
-      t.style.setProperty(`--brand-${n}-radius-card-${a}`, c);
-    }), i.input && Object.entries(i.input).forEach(([a, c]) => {
-      t.style.setProperty(`--brand-${n}-radius-input-${a}`, c);
+  if (overrides.accentColors) {
+    Object.entries(overrides.accentColors).forEach(([key, value]) => {
+      root.style.setProperty(`--brand-${namespace}-accent-${key}`, value);
     });
   }
-  O(r), t.setAttribute("data-brand", r.id), t.setAttribute("data-brand-namespace", n);
+  if (overrides.secondaryColors) {
+    Object.entries(overrides.secondaryColors).forEach(([key, value]) => {
+      root.style.setProperty(`--brand-${namespace}-secondary-${key}`, value);
+    });
+  }
+  const modeColors = mode === "day" ? overrides.baseColorsDay : overrides.baseColorsNight;
+  if (modeColors) {
+    Object.entries(modeColors).forEach(([key, value]) => {
+      root.style.setProperty(`--brand-${namespace}-${key}`, value);
+    });
+  }
+  if (overrides.typography) {
+    if (overrides.typography.fontFamily) {
+      Object.entries(overrides.typography.fontFamily).forEach(([key, value]) => {
+        root.style.setProperty(
+          `--brand-${namespace}-font-${key}`,
+          Array.isArray(value) ? value.join(", ") : value
+        );
+      });
+    }
+    if (overrides.typography.fontSize) {
+      Object.entries(overrides.typography.fontSize).forEach(([key, value]) => {
+        const fontSizeValue = typeof value === "string" ? value : value[0];
+        root.style.setProperty(`--brand-${namespace}-font-size-${key}`, fontSizeValue);
+      });
+    }
+    if (overrides.typography.fontWeight) {
+      Object.entries(overrides.typography.fontWeight).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-font-weight-${key}`, value);
+      });
+    }
+    if (overrides.typography.lineHeight) {
+      Object.entries(overrides.typography.lineHeight).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-line-height-${key}`, value);
+      });
+    }
+    if (overrides.typography.letterSpacing) {
+      Object.entries(overrides.typography.letterSpacing).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-letter-spacing-${key}`, value);
+      });
+    }
+  }
+  if (overrides.spacing) {
+    if (overrides.spacing.semanticSpacing) {
+      Object.entries(overrides.spacing.semanticSpacing).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-spacing-${key}`, value);
+      });
+    }
+    if (overrides.spacing.layoutSpacing) {
+      const layout = overrides.spacing.layoutSpacing;
+      if (layout.section) {
+        Object.entries(layout.section).forEach(([key, value]) => {
+          if (typeof value === "string") {
+            root.style.setProperty(`--brand-${namespace}-layout-section-${key}`, value);
+          }
+        });
+      }
+      if (layout.container) {
+        Object.entries(layout.container).forEach(([key, value]) => {
+          if (typeof value === "string") {
+            root.style.setProperty(`--brand-${namespace}-layout-container-${key}`, value);
+          }
+        });
+      }
+      if (layout.grid) {
+        Object.entries(layout.grid).forEach(([key, value]) => {
+          if (typeof value === "string") {
+            root.style.setProperty(`--brand-${namespace}-layout-grid-${key}`, value);
+          }
+        });
+      }
+      if (layout.stack) {
+        Object.entries(layout.stack).forEach(([key, value]) => {
+          if (typeof value === "string") {
+            root.style.setProperty(`--brand-${namespace}-layout-stack-${key}`, value);
+          }
+        });
+      }
+      if (layout.component) {
+        Object.entries(layout.component).forEach(([key, value]) => {
+          if (typeof value === "string") {
+            root.style.setProperty(`--brand-${namespace}-layout-component-${key}`, value);
+          }
+        });
+      }
+    }
+  }
+  if (overrides.shadows) {
+    if (overrides.shadows.elevationShadows) {
+      Object.entries(overrides.shadows.elevationShadows).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-shadow-${key}`, value);
+      });
+    }
+    if (overrides.shadows.primaryColoredShadows) {
+      Object.entries(overrides.shadows.primaryColoredShadows).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-shadow-primary-${key}`, value);
+      });
+    }
+    if (overrides.shadows.accentColoredShadows) {
+      Object.entries(overrides.shadows.accentColoredShadows).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-shadow-accent-${key}`, value);
+      });
+    }
+    if (overrides.shadows.glowEffects) {
+      Object.entries(overrides.shadows.glowEffects).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-glow-${key}`, value);
+      });
+    }
+    if (overrides.shadows.focusRings) {
+      Object.entries(overrides.shadows.focusRings).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-focus-ring-${key}`, value);
+      });
+    }
+  }
+  if (overrides.radius) {
+    if (overrides.radius.borderRadius) {
+      Object.entries(overrides.radius.borderRadius).forEach(([key, value]) => {
+        root.style.setProperty(`--brand-${namespace}-radius-${key}`, value);
+      });
+    }
+    if (overrides.radius.componentRadius) {
+      const { componentRadius } = overrides.radius;
+      if (componentRadius.button) {
+        Object.entries(componentRadius.button).forEach(([key, value]) => {
+          root.style.setProperty(`--brand-${namespace}-radius-button-${key}`, value);
+        });
+      }
+      if (componentRadius.card) {
+        Object.entries(componentRadius.card).forEach(([key, value]) => {
+          root.style.setProperty(`--brand-${namespace}-radius-card-${key}`, value);
+        });
+      }
+      if (componentRadius.input) {
+        Object.entries(componentRadius.input).forEach(([key, value]) => {
+          root.style.setProperty(`--brand-${namespace}-radius-input-${key}`, value);
+        });
+      }
+    }
+  }
+  setActiveBrand(brand);
+  root.setAttribute("data-brand", brand.id);
+  root.setAttribute("data-brand-namespace", namespace);
 }
-function ie(r) {
-  if (typeof document > "u") return;
-  const e = document.documentElement, { style: s } = e, t = [];
-  for (let n = 0; n < s.length; n++) {
-    const o = s.item(n);
-    o && o.startsWith(`--brand-${r}-`) && t.push(o);
-  }
-  t.forEach((n) => {
-    s.removeProperty(n);
-  }), e.removeAttribute("data-brand"), e.removeAttribute("data-brand-namespace"), M === r && Pe();
+function removeBrandOverrides(namespace) {
+  if (typeof document === "undefined") return;
+  const root = document.documentElement;
+  const { style } = root;
+  const propsToRemove = [];
+  for (let i = 0; i < style.length; i++) {
+    const prop = style.item(i);
+    if (prop && prop.startsWith(`--brand-${namespace}-`)) {
+      propsToRemove.push(prop);
+    }
+  }
+  propsToRemove.forEach((prop) => {
+    style.removeProperty(prop);
+  });
+  root.removeAttribute("data-brand");
+  root.removeAttribute("data-brand-namespace");
+  if (activeNamespace === namespace) {
+    clearActiveBrand();
+  }
 }
-const Ce = {
-  default: () => import("../default-BKgH1D9-.js").then((r) => r.defaultTheme),
-  dark: () => import("../dark-Cvoy1uFT.js").then((r) => r.darkTheme),
-  brand: () => import("../brand-C5R2semX.js").then((r) => r.brandTheme)
+
+// src/themes/index.ts
+var themes = {
+  default: () => Promise.resolve().then(() => (init_default(), default_exports)).then((m) => m.defaultTheme),
+  dark: () => Promise.resolve().then(() => (init_dark(), dark_exports)).then((m) => m.darkTheme),
+  brand: () => Promise.resolve().then(() => (init_brand(), brand_exports)).then((m) => m.brandTheme)
 };
-async function Ee(r) {
-  const e = Ce[r];
-  if (!e)
-    throw new Error(`Theme "${r}" not found`);
-  return await e();
+async function getTheme(name) {
+  const themeLoader = themes[name];
+  if (!themeLoader) {
+    throw new Error(`Theme "${name}" not found`);
+  }
+  return await themeLoader();
 }
-const le = "data-mode", I = "data-theme-name", ce = "data-theme", Y = "dark";
-function Se(r = "day", e = "tm_mode", s = !0) {
-  if (typeof window > "u") return r;
-  const t = document.documentElement, n = t.getAttribute(le);
-  if (n === "day" || n === "night")
-    return n;
-  const o = t.getAttribute(ce);
-  if (o === "day" || o === "night")
-    return o;
+
+// src/tokens/colors.ts
+var primaryColors = {
+  50: "210 40% 98%",
+  // Lightest blue
+  100: "210 40% 96%",
+  200: "217 32.6% 17.5%",
+  300: "216 28% 26%",
+  400: "215 25% 27%",
+  500: "215 20% 35%",
+  // Base primary
+  600: "215 16% 47%",
+  700: "216 12% 54%",
+  800: "217 10% 62%",
+  900: "222 47.4% 11.2%",
+  950: "222 84% 4.9%"
+  // Darkest blue
+};
+var accentColors = {
+  50: "280 100% 98%",
+  100: "280 65% 96%",
+  200: "280 60% 85%",
+  300: "280 55% 75%",
+  400: "280 50% 65%",
+  500: "280 70% 67%",
+  // Base accent (night mode primary)
+  600: "259 65% 58%",
+  700: "259 60% 50%",
+  800: "259 55% 45%",
+  900: "259 50% 40%",
+  950: "259 45% 30%"
+};
+var secondaryColors = {
+  50: "173 100% 98%",
+  100: "173 100% 95%",
+  200: "173 100% 85%",
+  300: "173 100% 70%",
+  400: "173 100% 55%",
+  500: "173 100% 37%",
+  // Base secondary (Tenerife #00bfa6)
+  600: "173 100% 32%",
+  700: "173 95% 27%",
+  800: "173 90% 22%",
+  900: "173 85% 17%",
+  950: "173 80% 12%"
+};
+var surfaceColors = {
+  day: {
+    base: "0 0% 100%",
+    // White background
+    elevated1: "0 0% 98%",
+    // Slightly elevated
+    elevated2: "0 0% 96%",
+    // More elevated
+    elevated3: "0 0% 94%",
+    // Most elevated
+    overlay: "0 0% 0% / 0.5",
+    // Overlay backdrop
+    glass: "0 0% 100% / 0.8"
+    // Glass effect
+  },
+  night: {
+    base: "240 10% 3.9%",
+    // Dark background (#0b0b10)
+    elevated1: "240 10% 5.1%",
+    // #0e1016
+    elevated2: "240 10% 6.3%",
+    // Slightly lighter
+    elevated3: "240 10% 7.5%",
+    // Even lighter
+    overlay: "0 0% 0% / 0.7",
+    // Darker overlay
+    glass: "240 10% 10% / 0.9"
+    // Dark glass effect
+  }
+};
+var semanticColors = {
+  day: {
+    success: "142 70% 28%",
+    // Darker green for better contrast
+    successForeground: "0 0% 100%",
+    error: "0 80% 40%",
+    // Richer red for contrast
+    errorForeground: "0 0% 100%",
+    warning: "38 92% 50%",
+    // Orange
+    warningForeground: "0 0% 9%",
+    info: "199 89% 48%",
+    // Blue
+    infoForeground: "0 0% 100%"
+  },
+  night: {
+    success: "142 70% 45%",
+    successForeground: "0 0% 100%",
+    error: "0 62.8% 30.6%",
+    // Darker red
+    errorForeground: "0 0% 98%",
+    warning: "38 92% 33%",
+    // Darker orange for WCAG AA contrast with white text
+    warningForeground: "0 0% 100%",
+    // Light foreground for dark theme readability
+    info: "199 89% 35%",
+    // Darker blue for WCAG AA contrast with white text
+    infoForeground: "0 0% 100%"
+    // Light foreground for dark theme readability
+  }
+};
+var chartColors = {
+  day: {
+    chart1: "12 76% 61%",
+    // Orange-red
+    chart2: "173 58% 39%",
+    // Teal-cyan
+    chart3: "197 37% 24%",
+    // Dark blue
+    chart4: "43 74% 66%",
+    // Yellow
+    chart5: "27 87% 67%"
+    // Orange
+  },
+  night: {
+    chart1: "220 70% 50%",
+    // Blue
+    chart2: "160 60% 45%",
+    // Teal
+    chart3: "30 80% 55%",
+    // Orange
+    chart4: "280 65% 60%",
+    // Purple
+    chart5: "340 75% 55%"
+    // Pink
+  }
+};
+var textColors = {
+  day: {
+    primary: "0 0% 9%",
+    // Almost black
+    secondary: "0 0% 45%",
+    // Medium gray
+    tertiary: "0 0% 65%",
+    // Light gray
+    muted: "0 0% 38%",
+    // Muted gray with stronger contrast
+    inverse: "0 0% 100%"
+    // White (for dark backgrounds)
+  },
+  night: {
+    primary: "0 0% 89.8%",
+    // Light gray (#e5e7eb)
+    secondary: "240 5% 64.9%",
+    // Medium gray
+    tertiary: "240 5% 50%",
+    // Darker gray
+    muted: "240 5% 64.9%",
+    // Muted gray
+    inverse: "0 0% 9%"
+    // Almost black (for light backgrounds)
+  }
+};
+var baseColors = {
+  day: {
+    background: "0 0% 100%",
+    foreground: "0 0% 9%",
+    card: "0 0% 100%",
+    cardForeground: "0 0% 9%",
+    popover: "0 0% 100%",
+    popoverForeground: "0 0% 9%",
+    border: "0 0% 89.8%",
+    input: "0 0% 89.8%",
+    ring: "0 0% 3.9%"
+  },
+  night: {
+    background: "240 10% 3.9%",
+    // #0b0b10
+    foreground: "0 0% 89.8%",
+    // #e5e7eb
+    card: "240 10% 3.9%",
+    cardForeground: "0 0% 89.8%",
+    popover: "240 10% 5.1%",
+    // #0e1016
+    popoverForeground: "0 0% 89.8%",
+    border: "240 3.7% 15.9%",
+    input: "240 3.7% 15.9%",
+    ring: "240 4.9% 83.9%"
+  }
+};
+var cssVariableColorTokens = {
+  day: {
+    ...baseColors.day,
+    primary: "hsl(var(--tm-primary))",
+    primaryForeground: "hsl(var(--tm-primary-foreground))",
+    secondary: "hsl(var(--tm-secondary))",
+    secondaryForeground: "hsl(var(--tm-secondary-foreground))",
+    muted: "hsl(var(--muted))",
+    mutedForeground: "hsl(var(--muted-foreground))",
+    accent: "hsl(var(--tm-accent))",
+    accentForeground: "hsl(var(--tm-accent-foreground))",
+    destructive: `hsl(${semanticColors.day.error})`,
+    destructiveForeground: semanticColors.day.errorForeground,
+    chart1: `hsl(${chartColors.day.chart1})`,
+    chart2: `hsl(${chartColors.day.chart2})`,
+    chart3: `hsl(${chartColors.day.chart3})`,
+    chart4: `hsl(${chartColors.day.chart4})`,
+    chart5: `hsl(${chartColors.day.chart5})`
+  },
+  night: {
+    ...baseColors.night,
+    primary: "hsl(var(--tm-primary))",
+    primaryForeground: "hsl(var(--tm-primary-foreground))",
+    secondary: "hsl(var(--tm-secondary))",
+    secondaryForeground: "hsl(var(--tm-secondary-foreground))",
+    muted: "hsl(var(--muted))",
+    mutedForeground: "hsl(var(--muted-foreground))",
+    accent: "hsl(var(--tm-accent))",
+    accentForeground: "hsl(var(--tm-accent-foreground))",
+    destructive: `hsl(${semanticColors.night.error})`,
+    destructiveForeground: semanticColors.night.errorForeground,
+    chart1: `hsl(${chartColors.night.chart1})`,
+    chart2: `hsl(${chartColors.night.chart2})`,
+    chart3: `hsl(${chartColors.night.chart3})`,
+    chart4: `hsl(${chartColors.night.chart4})`,
+    chart5: `hsl(${chartColors.night.chart5})`
+  }
+};
+({
+  // Primary scale
+  "--primary-50": primaryColors[50],
+  "--primary-100": primaryColors[100],
+  "--primary-200": primaryColors[200],
+  "--primary-300": primaryColors[300],
+  "--primary-400": primaryColors[400],
+  "--primary-500": primaryColors[500],
+  "--primary-600": primaryColors[600],
+  "--primary-700": primaryColors[700],
+  "--primary-800": primaryColors[800],
+  "--primary-900": primaryColors[900],
+  "--primary-950": primaryColors[950],
+  // Accent scale
+  "--accent-50": accentColors[50],
+  "--accent-100": accentColors[100],
+  "--accent-200": accentColors[200],
+  "--accent-300": accentColors[300],
+  "--accent-400": accentColors[400],
+  "--accent-500": accentColors[500],
+  "--accent-600": accentColors[600],
+  "--accent-700": accentColors[700],
+  "--accent-800": accentColors[800],
+  "--accent-900": accentColors[900],
+  "--accent-950": accentColors[950],
+  // Secondary scale
+  "--secondary-50": secondaryColors[50],
+  "--secondary-100": secondaryColors[100],
+  "--secondary-200": secondaryColors[200],
+  "--secondary-300": secondaryColors[300],
+  "--secondary-400": secondaryColors[400],
+  "--secondary-500": secondaryColors[500],
+  "--secondary-600": secondaryColors[600],
+  "--secondary-700": secondaryColors[700],
+  "--secondary-800": secondaryColors[800],
+  "--secondary-900": secondaryColors[900],
+  "--secondary-950": secondaryColors[950]
+  // Surface colors (mode-dependent, set dynamically by theme system)
+  // Note: These are set via updateCSSVariablesFromTokens() in applyMode.ts
+  // Semantic colors (mode-dependent, set dynamically by theme system)
+  // Note: These are set via updateCSSVariablesFromTokens() in applyMode.ts
+  // Text colors (mode-dependent, set dynamically by theme system)
+  // Note: These are set via updateCSSVariablesFromTokens() in applyMode.ts
+  // Chart colors (mode-dependent, set dynamically by theme system)
+  // Note: These are set via updateCSSVariablesFromTokens() in applyMode.ts
+});
+var tailwindThemeColors = {
+  // Base colors
+  background: "hsl(var(--background))",
+  foreground: "hsl(var(--foreground))",
+  // Card colors
+  card: {
+    DEFAULT: "hsl(var(--card))",
+    foreground: "hsl(var(--card-foreground))"
+  },
+  // Popover colors
+  popover: {
+    DEFAULT: "hsl(var(--popover))",
+    foreground: "hsl(var(--popover-foreground))"
+  },
+  // Primary colors (using CSS variables)
+  primary: {
+    DEFAULT: "hsl(var(--tm-primary))",
+    foreground: "hsl(var(--tm-primary-foreground))",
+    50: `hsl(var(--primary-50))`,
+    100: `hsl(var(--primary-100))`,
+    200: `hsl(var(--primary-200))`,
+    300: `hsl(var(--primary-300))`,
+    400: `hsl(var(--primary-400))`,
+    500: `hsl(var(--primary-500))`,
+    600: `hsl(var(--primary-600))`,
+    700: `hsl(var(--primary-700))`,
+    800: `hsl(var(--primary-800))`,
+    900: `hsl(var(--primary-900))`,
+    950: `hsl(var(--primary-950))`
+  },
+  // Secondary colors
+  secondary: {
+    DEFAULT: "hsl(var(--tm-secondary))",
+    foreground: "hsl(var(--tm-secondary-foreground))",
+    50: `hsl(var(--secondary-50))`,
+    100: `hsl(var(--secondary-100))`,
+    200: `hsl(var(--secondary-200))`,
+    300: `hsl(var(--secondary-300))`,
+    400: `hsl(var(--secondary-400))`,
+    500: `hsl(var(--secondary-500))`,
+    600: `hsl(var(--secondary-600))`,
+    700: `hsl(var(--secondary-700))`,
+    800: `hsl(var(--secondary-800))`,
+    900: `hsl(var(--secondary-900))`,
+    950: `hsl(var(--secondary-950))`
+  },
+  // Accent colors
+  accent: {
+    DEFAULT: "hsl(var(--tm-accent))",
+    foreground: "hsl(var(--tm-accent-foreground))",
+    50: `hsl(var(--accent-50))`,
+    100: `hsl(var(--accent-100))`,
+    200: `hsl(var(--accent-200))`,
+    300: `hsl(var(--accent-300))`,
+    400: `hsl(var(--accent-400))`,
+    500: `hsl(var(--accent-500))`,
+    600: `hsl(var(--accent-600))`,
+    700: `hsl(var(--accent-700))`,
+    800: `hsl(var(--accent-800))`,
+    900: `hsl(var(--accent-900))`,
+    950: `hsl(var(--accent-950))`
+  },
+  // Muted colors
+  muted: {
+    DEFAULT: "hsl(var(--muted))",
+    foreground: "hsl(var(--muted-foreground))"
+  },
+  // Destructive colors (semantic error)
+  destructive: {
+    DEFAULT: "hsl(var(--destructive))",
+    foreground: "hsl(var(--destructive-foreground))"
+  },
+  // Semantic colors
+  success: {
+    DEFAULT: `hsl(var(--semantic-success))`,
+    foreground: `hsl(var(--semantic-success-foreground))`
+  },
+  error: {
+    DEFAULT: `hsl(var(--semantic-error))`,
+    foreground: `hsl(var(--semantic-error-foreground))`
+  },
+  warning: {
+    DEFAULT: `hsl(var(--semantic-warning))`,
+    foreground: `hsl(var(--semantic-warning-foreground))`
+  },
+  info: {
+    DEFAULT: `hsl(var(--semantic-info))`,
+    foreground: `hsl(var(--semantic-info-foreground))`
+  },
+  // Surface colors
+  surface: {
+    base: `hsl(var(--surface-base))`,
+    elevated1: `hsl(var(--surface-elevated1))`,
+    elevated2: `hsl(var(--surface-elevated2))`,
+    elevated3: `hsl(var(--surface-elevated3))`,
+    overlay: `hsl(var(--surface-overlay))`,
+    glass: `hsl(var(--surface-glass))`
+  },
+  // Text colors
+  text: {
+    primary: `hsl(var(--text-primary))`,
+    secondary: `hsl(var(--text-secondary))`,
+    tertiary: `hsl(var(--text-tertiary))`,
+    muted: `hsl(var(--text-muted))`,
+    destructive: `hsl(var(--destructive))`,
+    accent: `hsl(var(--tm-accent))`,
+    inverse: `hsl(var(--text-inverse))`
+  },
+  // Border and input
+  border: "hsl(var(--border))",
+  input: "hsl(var(--input))",
+  ring: "hsl(var(--ring))",
+  // Chart colors (using CSS variables)
+  chart: {
+    1: `hsl(var(--chart-1))`,
+    2: `hsl(var(--chart-2))`,
+    3: `hsl(var(--chart-3))`,
+    4: `hsl(var(--chart-4))`,
+    5: `hsl(var(--chart-5))`
+  }
+};
+
+// src/tokens/motion.ts
+var durations = {
+  instant: "0ms",
+  fast: "150ms",
+  // 1.5 × base (quick interactions)
+  normal: "300ms",
+  // 3 × base (default)
+  slow: "500ms",
+  // 5 × base (emphasized)
+  slower: "700ms",
+  // 7 × base (very emphasized)
+  slowest: "1000ms",
+  // 10 × base (maximum emphasis)
+  // Additional granular durations
+  "75": "75ms",
+  // Ultra-fast
+  "100": "100ms",
+  // Base unit
+  "200": "200ms",
+  // Fast-normal
+  "250": "250ms",
+  // Between fast and normal
+  "400": "400ms",
+  // Between normal and slow
+  "600": "600ms",
+  // Between slow and slower
+  "800": "800ms"
+  // Between slower and slowest
+};
+var easings = {
+  // Linear (no easing)
+  linear: "linear",
+  // Ease-in (accelerate) - cubic-bezier
+  "ease-in": "cubic-bezier(0.4, 0, 1, 1)",
+  // Ease-out (decelerate) - recommended for most UI - cubic-bezier
+  "ease-out": "cubic-bezier(0, 0, 0.2, 1)",
+  // Ease-in-out (accelerate and decelerate)
+  "ease-in-out": "cubic-bezier(0.4, 0, 0.2, 1)",
+  // Advanced easing functions
+  bounce: "cubic-bezier(0.68, -0.55, 0.265, 1.55)",
+  elastic: "cubic-bezier(0.175, 0.885, 0.32, 1.275)",
+  // Material Design easing
+  "ease-out-cubic": "cubic-bezier(0.215, 0.61, 0.355, 1)",
+  "ease-in-cubic": "cubic-bezier(0.55, 0.055, 0.675, 0.19)",
+  "ease-in-out-cubic": "cubic-bezier(0.645, 0.045, 0.355, 1)"
+};
+var transitions = {
+  // Fast transitions (quick interactions)
+  fast: `${durations.fast} ${easings["ease-out"]}`,
+  "fast-in": `${durations.fast} ${easings["ease-in"]}`,
+  "fast-out": `${durations.fast} ${easings["ease-out"]}`,
+  "fast-in-out": `${durations.fast} ${easings["ease-in-out"]}`,
+  // Normal transitions (default)
+  normal: `${durations.normal} ${easings["ease-in-out"]}`,
+  "normal-in": `${durations.normal} ${easings["ease-in"]}`,
+  "normal-out": `${durations.normal} ${easings["ease-out"]}`,
+  "normal-in-out": `${durations.normal} ${easings["ease-in-out"]}`,
+  // Slow transitions (emphasized)
+  slow: `${durations.slow} ${easings["ease-in-out"]}`,
+  "slow-in": `${durations.slow} ${easings["ease-in"]}`,
+  "slow-out": `${durations.slow} ${easings["ease-out"]}`,
+  "slow-in-out": `${durations.slow} ${easings["ease-in-out"]}`,
+  // Special transitions
+  bounce: `${durations.normal} ${easings.bounce}`,
+  elastic: `${durations.slow} ${easings.elastic}`,
+  // Default (normal)
+  DEFAULT: `${durations.normal} ${easings["ease-in-out"]}`
+};
+var motionCSSVariables = {
+  // Durations
+  "--duration-instant": durations.instant,
+  "--duration-fast": durations.fast,
+  "--duration-normal": durations.normal,
+  "--duration-slow": durations.slow,
+  "--duration-slower": durations.slower,
+  "--duration-slowest": durations.slowest,
+  // Additional granular durations
+  "--duration-75": durations["75"],
+  "--duration-100": durations["100"],
+  "--duration-200": durations["200"],
+  "--duration-250": durations["250"],
+  "--duration-400": durations["400"],
+  "--duration-600": durations["600"],
+  "--duration-800": durations["800"],
+  // Easings
+  "--ease-linear": easings.linear,
+  "--ease-in": easings["ease-in"],
+  "--ease-out": easings["ease-out"],
+  "--ease-in-out": easings["ease-in-out"],
+  "--ease-bounce": easings.bounce,
+  "--ease-elastic": easings.elastic,
+  "--ease-out-cubic": easings["ease-out-cubic"],
+  "--ease-in-cubic": easings["ease-in-cubic"],
+  "--ease-in-out-cubic": easings["ease-in-out-cubic"],
+  // Transitions
+  "--transition-fast": transitions.fast,
+  "--transition-normal": transitions.normal,
+  "--transition-slow": transitions.slow,
+  "--transition-default": transitions.DEFAULT,
+  "--transition-fast-in": transitions["fast-in"],
+  "--transition-fast-out": transitions["fast-out"],
+  "--transition-fast-in-out": transitions["fast-in-out"],
+  "--transition-normal-in": transitions["normal-in"],
+  "--transition-normal-out": transitions["normal-out"],
+  "--transition-normal-in-out": transitions["normal-in-out"],
+  "--transition-slow-in": transitions["slow-in"],
+  "--transition-slow-out": transitions["slow-out"],
+  "--transition-slow-in-out": transitions["slow-in-out"],
+  "--transition-bounce": transitions.bounce,
+  "--transition-elastic": transitions.elastic
+};
+
+// src/theme/applyMode.ts
+var MODE_ATTRIBUTE = "data-mode";
+var THEME_ATTRIBUTE = "data-theme-name";
+var MODE_THEME_ATTRIBUTE = "data-theme";
+var DARK_CLASS = "dark";
+function getInitialMode(defaultMode = "day", storageKey = "tm_mode", enableSystem = true) {
+  if (typeof window === "undefined") return defaultMode;
+  const root = document.documentElement;
+  const attr = root.getAttribute(MODE_ATTRIBUTE);
+  if (attr === "day" || attr === "night") {
+    return attr;
+  }
+  const themeAttr = root.getAttribute(MODE_THEME_ATTRIBUTE);
+  if (themeAttr === "day" || themeAttr === "night") {
+    return themeAttr;
+  }
   try {
-    const m = localStorage.getItem(e);
-    if (m === "day" || m === "night")
-      return m;
-    const i = localStorage.getItem("theme");
-    if (i === "dark") return "night";
-    if (i === "light") return "day";
+    const stored = localStorage.getItem(storageKey);
+    if (stored === "day" || stored === "night") {
+      return stored;
+    }
+    const legacy = localStorage.getItem("theme");
+    if (legacy === "dark") return "night";
+    if (legacy === "light") return "day";
   } catch {
   }
-  return s && typeof window < "u" ? window.matchMedia("(prefers-color-scheme: dark)").matches ? "night" : "day" : r;
+  if (enableSystem && typeof window !== "undefined") {
+    const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+    return prefersDark ? "night" : "day";
+  }
+  return defaultMode;
 }
-let R = null;
-async function Te(r) {
-  if (r === "default")
-    return R = null, null;
+var currentThemeOverride = null;
+async function loadThemeOverride(themeName) {
+  if (themeName === "default") {
+    currentThemeOverride = null;
+    return null;
+  }
   try {
-    const e = await Ee(r);
-    return R = e, e;
-  } catch (e) {
-    return console.warn(`Failed to load theme "${r}":`, e), R = null, null;
+    const theme = await getTheme(themeName);
+    currentThemeOverride = theme;
+    return theme;
+  } catch (error) {
+    console.warn(`Failed to load theme "${themeName}":`, error);
+    currentThemeOverride = null;
+    return null;
   }
 }
-function A(r, e) {
-  return e ? { ...r, ...e } : r;
+function mergeColorScale(base, override) {
+  if (!override) return base;
+  return { ...base, ...override };
 }
-function w(r, e) {
-  return e ? { ...r, ...e } : r;
+function mergeObject(base, override) {
+  if (!override) return base;
+  return { ...base, ...override };
 }
-function me(r) {
-  const e = R, s = A(ge, e == null ? void 0 : e.primaryColors), t = A(he, e == null ? void 0 : e.accentColors), n = A(xe, e == null ? void 0 : e.secondaryColors), o = {
-    day: w(q.day, e == null ? void 0 : e.baseColorsDay),
-    night: w(q.night, e == null ? void 0 : e.baseColorsNight)
-  }, m = {
-    day: w(V.day, e == null ? void 0 : e.surfaceColorsDay),
-    night: w(V.night, e == null ? void 0 : e.surfaceColorsNight)
-  }, i = {
-    day: w(Q.day, e == null ? void 0 : e.semanticColorsDay),
-    night: w(Q.night, e == null ? void 0 : e.semanticColorsNight)
-  }, a = {
-    day: w(G.day, e == null ? void 0 : e.textColorsDay),
-    night: w(G.night, e == null ? void 0 : e.textColorsNight)
-  }, c = {
-    day: J.day,
-    night: J.night
+function getMergedTokens(_mode) {
+  const override = currentThemeOverride;
+  const primaryColors2 = mergeColorScale(primaryColors, override?.primaryColors);
+  const accentColors2 = mergeColorScale(accentColors, override?.accentColors);
+  const secondaryColors2 = mergeColorScale(secondaryColors, override?.secondaryColors);
+  const baseColors2 = {
+    day: mergeObject(baseColors.day, override?.baseColorsDay),
+    night: mergeObject(baseColors.night, override?.baseColorsNight)
+  };
+  const surfaceColors2 = {
+    day: mergeObject(surfaceColors.day, override?.surfaceColorsDay),
+    night: mergeObject(surfaceColors.night, override?.surfaceColorsNight)
+  };
+  const semanticColors2 = {
+    day: mergeObject(semanticColors.day, override?.semanticColorsDay),
+    night: mergeObject(semanticColors.night, override?.semanticColorsNight)
+  };
+  const textColors2 = {
+    day: mergeObject(textColors.day, override?.textColorsDay),
+    night: mergeObject(textColors.night, override?.textColorsNight)
+  };
+  const chartColors2 = {
+    day: chartColors.day,
+    night: chartColors.night
   };
   return {
-    primaryColors: s,
-    accentColors: t,
-    secondaryColors: n,
-    baseColors: o,
-    surfaceColors: m,
-    semanticColors: i,
-    textColors: a,
-    chartColors: c
+    primaryColors: primaryColors2,
+    accentColors: accentColors2,
+    secondaryColors: secondaryColors2,
+    baseColors: baseColors2,
+    surfaceColors: surfaceColors2,
+    semanticColors: semanticColors2,
+    textColors: textColors2,
+    chartColors: chartColors2
   };
 }
-function ke(r) {
-  if (typeof document > "u") return;
-  const e = document.documentElement, s = me(), {
-    primaryColors: t,
-    accentColors: n,
-    secondaryColors: o,
-    baseColors: m,
-    surfaceColors: i,
-    semanticColors: a,
-    textColors: c,
-    chartColors: x
-  } = s, d = m[r];
-  e.style.setProperty("--background", d.background), e.style.setProperty("--foreground", d.foreground), e.style.setProperty("--card", d.card), e.style.setProperty("--card-foreground", d.cardForeground), e.style.setProperty("--popover", d.popover), e.style.setProperty("--popover-foreground", d.popoverForeground), e.style.setProperty("--border", d.border), e.style.setProperty("--input", d.input), e.style.setProperty("--ring", d.ring);
-  const h = i[r];
-  e.style.setProperty("--surface-base", h.base), e.style.setProperty("--surface-elevated1", h.elevated1), e.style.setProperty("--surface-elevated2", h.elevated2), e.style.setProperty("--surface-elevated3", h.elevated3), e.style.setProperty("--surface-overlay", h.overlay), e.style.setProperty("--surface-glass", h.glass);
-  const y = a[r];
-  e.style.setProperty("--semantic-success", y.success), e.style.setProperty("--semantic-success-foreground", y.successForeground), e.style.setProperty("--semantic-error", y.error), e.style.setProperty("--semantic-error-foreground", y.errorForeground), e.style.setProperty("--semantic-warning", y.warning), e.style.setProperty("--semantic-warning-foreground", y.warningForeground), e.style.setProperty("--semantic-info", y.info), e.style.setProperty("--semantic-info-foreground", y.infoForeground);
-  const b = c[r];
-  e.style.setProperty("--text-primary", b.primary), e.style.setProperty("--text-secondary", b.secondary), e.style.setProperty("--text-tertiary", b.tertiary), e.style.setProperty("--text-muted", b.muted), e.style.setProperty("--text-inverse", b.inverse);
-  const g = x[r];
-  e.style.setProperty("--chart-1", g.chart1), e.style.setProperty("--chart-2", g.chart2), e.style.setProperty("--chart-3", g.chart3), e.style.setProperty("--chart-4", g.chart4), e.style.setProperty("--chart-5", g.chart5), e.style.setProperty("--primary-50", t[50]), e.style.setProperty("--primary-100", t[100]), e.style.setProperty("--primary-200", t[200]), e.style.setProperty("--primary-300", t[300]), e.style.setProperty("--primary-400", t[400]), e.style.setProperty("--primary-500", t[500]), e.style.setProperty("--primary-600", t[600]), e.style.setProperty("--primary-700", t[700]), e.style.setProperty("--primary-800", t[800]), e.style.setProperty("--primary-900", t[900]), e.style.setProperty("--primary-950", t[950]), e.style.setProperty("--accent-50", n[50]), e.style.setProperty("--accent-100", n[100]), e.style.setProperty("--accent-200", n[200]), e.style.setProperty("--accent-300", n[300]), e.style.setProperty("--accent-400", n[400]), e.style.setProperty("--accent-500", n[500]), e.style.setProperty("--accent-600", n[600]), e.style.setProperty("--accent-700", n[700]), e.style.setProperty("--accent-800", n[800]), e.style.setProperty("--accent-900", n[900]), e.style.setProperty("--accent-950", n[950]), e.style.setProperty("--secondary-50", o[50]), e.style.setProperty("--secondary-100", o[100]), e.style.setProperty("--secondary-200", o[200]), e.style.setProperty("--secondary-300", o[300]), e.style.setProperty("--secondary-400", o[400]), e.style.setProperty("--secondary-500", o[500]), e.style.setProperty("--secondary-600", o[600]), e.style.setProperty("--secondary-700", o[700]), e.style.setProperty("--secondary-800", o[800]), e.style.setProperty("--secondary-900", o[900]), e.style.setProperty("--secondary-950", o[950]), r === "day" ? (e.style.setProperty("--tm-primary", o[500]), e.style.setProperty("--tm-primary-foreground", "0 0% 100%"), e.style.setProperty("--tm-secondary", "0 0% 95.7%"), e.style.setProperty("--tm-secondary-foreground", "0 0% 6.7%"), e.style.setProperty("--tm-accent", "0 0% 89.8%"), e.style.setProperty("--tm-accent-foreground", "0 0% 6.7%")) : (e.style.setProperty("--tm-primary", n[600]), e.style.setProperty("--tm-primary-foreground", "0 0% 100%"), e.style.setProperty("--tm-secondary", "240 10% 7%"), e.style.setProperty("--tm-secondary-foreground", "0 0% 89.8%"), e.style.setProperty("--tm-accent", "240 10% 10%"), e.style.setProperty("--tm-accent-foreground", "0 0% 89.8%")), e.style.setProperty("--muted", d.card), e.style.setProperty("--muted-foreground", d.cardForeground), e.style.setProperty("--destructive", y.error), e.style.setProperty("--destructive-foreground", y.errorForeground), Object.entries(fe).forEach(([T, k]) => {
-    e.style.setProperty(T, k);
+function updateCSSVariablesFromTokens(mode) {
+  if (typeof document === "undefined") return;
+  const root = document.documentElement;
+  const tokens = getMergedTokens();
+  const {
+    primaryColors: primaryColors2,
+    accentColors: accentColors2,
+    secondaryColors: secondaryColors2,
+    baseColors: baseColors2,
+    surfaceColors: surfaceColors2,
+    semanticColors: semanticColors2,
+    textColors: textColors2,
+    chartColors: chartColors2
+  } = tokens;
+  const base = baseColors2[mode];
+  root.style.setProperty("--background", base.background);
+  root.style.setProperty("--foreground", base.foreground);
+  root.style.setProperty("--card", base.card);
+  root.style.setProperty("--card-foreground", base.cardForeground);
+  root.style.setProperty("--popover", base.popover);
+  root.style.setProperty("--popover-foreground", base.popoverForeground);
+  root.style.setProperty("--border", base.border);
+  root.style.setProperty("--input", base.input);
+  root.style.setProperty("--ring", base.ring);
+  const surface = surfaceColors2[mode];
+  root.style.setProperty("--surface-base", surface.base);
+  root.style.setProperty("--surface-elevated1", surface.elevated1);
+  root.style.setProperty("--surface-elevated2", surface.elevated2);
+  root.style.setProperty("--surface-elevated3", surface.elevated3);
+  root.style.setProperty("--surface-overlay", surface.overlay);
+  root.style.setProperty("--surface-glass", surface.glass);
+  const semantic = semanticColors2[mode];
+  root.style.setProperty("--semantic-success", semantic.success);
+  root.style.setProperty("--semantic-success-foreground", semantic.successForeground);
+  root.style.setProperty("--semantic-error", semantic.error);
+  root.style.setProperty("--semantic-error-foreground", semantic.errorForeground);
+  root.style.setProperty("--semantic-warning", semantic.warning);
+  root.style.setProperty("--semantic-warning-foreground", semantic.warningForeground);
+  root.style.setProperty("--semantic-info", semantic.info);
+  root.style.setProperty("--semantic-info-foreground", semantic.infoForeground);
+  const text = textColors2[mode];
+  root.style.setProperty("--text-primary", text.primary);
+  root.style.setProperty("--text-secondary", text.secondary);
+  root.style.setProperty("--text-tertiary", text.tertiary);
+  root.style.setProperty("--text-muted", text.muted);
+  root.style.setProperty("--text-inverse", text.inverse);
+  const chart = chartColors2[mode];
+  root.style.setProperty("--chart-1", chart.chart1);
+  root.style.setProperty("--chart-2", chart.chart2);
+  root.style.setProperty("--chart-3", chart.chart3);
+  root.style.setProperty("--chart-4", chart.chart4);
+  root.style.setProperty("--chart-5", chart.chart5);
+  root.style.setProperty("--primary-50", primaryColors2[50]);
+  root.style.setProperty("--primary-100", primaryColors2[100]);
+  root.style.setProperty("--primary-200", primaryColors2[200]);
+  root.style.setProperty("--primary-300", primaryColors2[300]);
+  root.style.setProperty("--primary-400", primaryColors2[400]);
+  root.style.setProperty("--primary-500", primaryColors2[500]);
+  root.style.setProperty("--primary-600", primaryColors2[600]);
+  root.style.setProperty("--primary-700", primaryColors2[700]);
+  root.style.setProperty("--primary-800", primaryColors2[800]);
+  root.style.setProperty("--primary-900", primaryColors2[900]);
+  root.style.setProperty("--primary-950", primaryColors2[950]);
+  root.style.setProperty("--accent-50", accentColors2[50]);
+  root.style.setProperty("--accent-100", accentColors2[100]);
+  root.style.setProperty("--accent-200", accentColors2[200]);
+  root.style.setProperty("--accent-300", accentColors2[300]);
+  root.style.setProperty("--accent-400", accentColors2[400]);
+  root.style.setProperty("--accent-500", accentColors2[500]);
+  root.style.setProperty("--accent-600", accentColors2[600]);
+  root.style.setProperty("--accent-700", accentColors2[700]);
+  root.style.setProperty("--accent-800", accentColors2[800]);
+  root.style.setProperty("--accent-900", accentColors2[900]);
+  root.style.setProperty("--accent-950", accentColors2[950]);
+  root.style.setProperty("--secondary-50", secondaryColors2[50]);
+  root.style.setProperty("--secondary-100", secondaryColors2[100]);
+  root.style.setProperty("--secondary-200", secondaryColors2[200]);
+  root.style.setProperty("--secondary-300", secondaryColors2[300]);
+  root.style.setProperty("--secondary-400", secondaryColors2[400]);
+  root.style.setProperty("--secondary-500", secondaryColors2[500]);
+  root.style.setProperty("--secondary-600", secondaryColors2[600]);
+  root.style.setProperty("--secondary-700", secondaryColors2[700]);
+  root.style.setProperty("--secondary-800", secondaryColors2[800]);
+  root.style.setProperty("--secondary-900", secondaryColors2[900]);
+  root.style.setProperty("--secondary-950", secondaryColors2[950]);
+  if (mode === "day") {
+    root.style.setProperty("--tm-primary", secondaryColors2[500]);
+    root.style.setProperty("--tm-primary-foreground", "0 0% 100%");
+    root.style.setProperty("--tm-secondary", "0 0% 95.7%");
+    root.style.setProperty("--tm-secondary-foreground", "0 0% 6.7%");
+    root.style.setProperty("--tm-accent", "0 0% 89.8%");
+    root.style.setProperty("--tm-accent-foreground", "0 0% 6.7%");
+  } else {
+    root.style.setProperty("--tm-primary", accentColors2[600]);
+    root.style.setProperty("--tm-primary-foreground", "0 0% 100%");
+    root.style.setProperty("--tm-secondary", "240 10% 7%");
+    root.style.setProperty("--tm-secondary-foreground", "0 0% 89.8%");
+    root.style.setProperty("--tm-accent", "240 10% 10%");
+    root.style.setProperty("--tm-accent-foreground", "0 0% 89.8%");
+  }
+  root.style.setProperty("--muted", base.card);
+  root.style.setProperty("--muted-foreground", base.cardForeground);
+  root.style.setProperty("--destructive", semantic.error);
+  root.style.setProperty("--destructive-foreground", semantic.errorForeground);
+  Object.entries(motionCSSVariables).forEach(([key, value]) => {
+    root.style.setProperty(key, value);
   });
 }
-async function $(r, e = "default", s = null) {
-  if (typeof document > "u") return;
-  await Te(e);
-  const t = se();
-  if (t && (!s || t.id !== s) && ie(t.namespace), s)
+async function applyDocumentTheme(mode, themeName = "default", brandId = null) {
+  if (typeof document === "undefined") return;
+  await loadThemeOverride(themeName);
+  const currentBrand = getActiveBrand();
+  if (currentBrand && (!brandId || currentBrand.id !== brandId)) {
+    removeBrandOverrides(currentBrand.namespace);
+  }
+  if (brandId) {
     try {
-      const c = await ne(s);
-      ae(c, r);
-    } catch (c) {
-      console.warn(`Failed to apply brand "${s}":`, c);
+      const brand = await loadBrand(brandId);
+      applyBrandOverrides(brand, mode);
+    } catch (error) {
+      console.warn(`Failed to apply brand "${brandId}":`, error);
     }
-  const { documentElement: n, body: o } = document;
-  n.setAttribute(le, r), n.setAttribute(ce, r), n.setAttribute(I, e), r === "night" ? n.classList.add(Y) : n.classList.remove(Y), ke(r);
-  const m = me(), { background: i, foreground: a } = m.baseColors[r];
-  o && (o.dataset.mode = r, o.dataset.theme = e, s ? o.dataset.brand = s : o.removeAttribute("data-brand"), o.style.backgroundColor = `hsl(${i})`, o.style.color = `hsl(${a})`);
+  }
+  const { documentElement: root, body } = document;
+  root.setAttribute(MODE_ATTRIBUTE, mode);
+  root.setAttribute(MODE_THEME_ATTRIBUTE, mode);
+  root.setAttribute(THEME_ATTRIBUTE, themeName);
+  if (mode === "night") {
+    root.classList.add(DARK_CLASS);
+  } else {
+    root.classList.remove(DARK_CLASS);
+  }
+  updateCSSVariablesFromTokens(mode);
+  const tokens = getMergedTokens();
+  const { background, foreground } = tokens.baseColors[mode];
+  if (body) {
+    body.dataset.mode = mode;
+    body.dataset.theme = themeName;
+    if (brandId) {
+      body.dataset.brand = brandId;
+    } else {
+      body.removeAttribute("data-brand");
+    }
+    body.style.backgroundColor = `hsl(${background})`;
+    body.style.color = `hsl(${foreground})`;
+  }
 }
-async function He(r) {
-  if (typeof document < "u") {
-    const e = document.documentElement, s = e.getAttribute(I) || "default", t = e.getAttribute("data-brand") || null;
-    await $(r, s, t);
-  } else
-    await $(r, "default", null);
+async function applyDocumentMode(mode) {
+  if (typeof document !== "undefined") {
+    const root = document.documentElement;
+    const currentTheme = root.getAttribute(THEME_ATTRIBUTE) || "default";
+    const currentBrand = root.getAttribute("data-brand") || null;
+    await applyDocumentTheme(mode, currentTheme, currentBrand);
+  } else {
+    await applyDocumentTheme(mode, "default", null);
+  }
 }
-function Z(r = "default", e = "tm_theme") {
-  if (typeof window > "u") return r;
-  const t = document.documentElement.getAttribute(I);
-  if (t === "default" || t === "dark" || t === "brand")
-    return t;
+function getInitialTheme(defaultTheme2 = "default", storageKey = "tm_theme") {
+  if (typeof window === "undefined") return defaultTheme2;
+  const root = document.documentElement;
+  const attr = root.getAttribute(THEME_ATTRIBUTE);
+  if (attr === "default" || attr === "dark" || attr === "brand") {
+    return attr;
+  }
   try {
-    const n = localStorage.getItem(e);
-    if (n === "default" || n === "dark" || n === "brand")
-      return n;
+    const stored = localStorage.getItem(storageKey);
+    if (stored === "default" || stored === "dark" || stored === "brand") {
+      return stored;
+    }
   } catch {
   }
-  return r;
+  return defaultTheme2;
 }
-function K(r, e = "tm_mode") {
-  if (!(typeof window > "u"))
-    try {
-      localStorage.setItem(e, r), localStorage.setItem("theme", r === "night" ? "dark" : "light");
-    } catch {
-    }
+function persistMode(mode, storageKey = "tm_mode") {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(storageKey, mode);
+    localStorage.setItem("theme", mode === "night" ? "dark" : "light");
+  } catch {
+  }
 }
-function ee(r, e = "tm_theme") {
-  if (!(typeof window > "u"))
-    try {
-      localStorage.setItem(e, r);
-    } catch {
-    }
+function persistTheme(theme, storageKey = "tm_theme") {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(storageKey, theme);
+  } catch {
+  }
 }
-function re(r = null, e = "tm_brand") {
-  if (typeof window > "u") return r;
-  const t = document.documentElement.getAttribute("data-brand");
-  if (t)
-    return t;
+function getInitialBrand(defaultBrand = null, storageKey = "tm_brand") {
+  if (typeof window === "undefined") return defaultBrand;
+  const root = document.documentElement;
+  const attr = root.getAttribute("data-brand");
+  if (attr) {
+    return attr;
+  }
   try {
-    const n = localStorage.getItem(e);
-    if (n)
-      return n;
+    const stored = localStorage.getItem(storageKey);
+    if (stored) {
+      return stored;
+    }
   } catch {
   }
-  return r;
+  return defaultBrand;
 }
-function te(r, e = "tm_brand") {
-  if (!(typeof window > "u"))
-    try {
-      r ? localStorage.setItem(e, r) : localStorage.removeItem(e);
-    } catch {
+function persistBrand(brandId, storageKey = "tm_brand") {
+  if (typeof window === "undefined") return;
+  try {
+    if (brandId) {
+      localStorage.setItem(storageKey, brandId);
+    } else {
+      localStorage.removeItem(storageKey);
     }
+  } catch {
+  }
 }
-const S = /* @__PURE__ */ new Map();
-function D(r) {
-  S.set(r.metadata.id, r);
+
+// src/theme/registry.ts
+var themeRegistry = /* @__PURE__ */ new Map();
+function registerTheme(entry) {
+  themeRegistry.set(entry.metadata.id, entry);
 }
-function _e(r) {
-  var e;
-  return (e = S.get(r)) == null ? void 0 : e.metadata;
+function getThemeMetadata(id) {
+  return themeRegistry.get(id)?.metadata;
 }
-function de() {
-  return Array.from(S.values()).filter((r) => r.enabled !== !1).map((r) => r.metadata);
+function getAllThemes() {
+  return Array.from(themeRegistry.values()).filter((entry) => entry.enabled !== false).map((entry) => entry.metadata);
 }
-function Ne(r) {
-  return de().filter((e) => e.category === r);
+function getThemesByCategory(category) {
+  return getAllThemes().filter((theme) => theme.category === category);
 }
-function C(r) {
-  return S.has(r);
+function themeExists(id) {
+  return themeRegistry.has(id);
 }
-async function je(r) {
-  const e = S.get(r);
-  if (!e)
-    throw new Error(`Theme "${r}" not found in registry`);
-  if (e.enabled === !1)
-    throw new Error(`Theme "${r}" is disabled`);
+async function loadTheme(id) {
+  const entry = themeRegistry.get(id);
+  if (!entry) {
+    throw new Error(`Theme "${id}" not found in registry`);
+  }
+  if (entry.enabled === false) {
+    throw new Error(`Theme "${id}" is disabled`);
+  }
   try {
-    return (await e.loader()).default;
-  } catch (s) {
+    const module = await entry.loader();
+    return module.default;
+  } catch (error) {
     throw new Error(
-      `Failed to load theme "${r}": ${s instanceof Error ? s.message : String(s)}`
+      `Failed to load theme "${id}": ${error instanceof Error ? error.message : String(error)}`
     );
   }
 }
-function Re() {
-  D({
+function initializeDefaultThemes() {
+  registerTheme({
     metadata: {
       id: "default",
       name: "Default",
@@ -1095,9 +2033,13 @@ function Re() {
       category: "default",
       version: "1.0.0"
     },
-    loader: async () => ({ default: { ...(await import("../default-BKgH1D9-.js")).defaultTheme, id: "default", name: "Default" } }),
-    enabled: !0
-  }), D({
+    loader: async () => {
+      const m = await Promise.resolve().then(() => (init_default(), default_exports));
+      return { default: { ...m.defaultTheme, id: "default", name: "Default" } };
+    },
+    enabled: true
+  });
+  registerTheme({
     metadata: {
       id: "dark",
       name: "Dark",
@@ -1105,9 +2047,13 @@ function Re() {
       category: "default",
       version: "1.0.0"
     },
-    loader: async () => ({ default: { ...(await import("../dark-Cvoy1uFT.js")).darkTheme, id: "dark", name: "Dark" } }),
-    enabled: !0
-  }), D({
+    loader: async () => {
+      const m = await Promise.resolve().then(() => (init_dark(), dark_exports));
+      return { default: { ...m.darkTheme, id: "dark", name: "Dark" } };
+    },
+    enabled: true
+  });
+  registerTheme({
     metadata: {
       id: "brand",
       name: "Brand",
@@ -1115,35 +2061,57 @@ function Re() {
       category: "brand",
       version: "1.0.0"
     },
-    loader: async () => ({ default: { ...(await import("../brand-C5R2semX.js")).brandTheme, id: "brand", name: "Brand" } }),
-    enabled: !0
+    loader: async () => {
+      const m = await Promise.resolve().then(() => (init_brand(), brand_exports));
+      return { default: { ...m.brandTheme, id: "brand", name: "Brand" } };
+    },
+    enabled: true
   });
 }
-Re();
-const Be = ["id", "name"];
-function pe(r) {
-  const e = [], s = [];
-  if (!r || typeof r != "object")
+initializeDefaultThemes();
+
+// src/theme/schema.ts
+var REQUIRED_FIELDS = ["id", "name"];
+function validateThemeSchema(theme) {
+  const errors = [];
+  const warnings = [];
+  if (!theme || typeof theme !== "object") {
     return {
-      valid: !1,
+      valid: false,
       errors: ["Theme must be an object"],
       warnings: []
     };
-  const t = r;
-  for (const o of Be)
-    (!(o in t) || !t[o]) && e.push(`Missing required field: ${o}`);
-  if (t.id && typeof t.id == "string" && (/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(t.id) || e.push(
-    `Invalid theme ID format: "${t.id}". Must be kebab-case (e.g., "ocean-blue")`
-  )), t.name && typeof t.name != "string" && e.push("Theme name must be a string"), t.category) {
-    const o = ["default", "brand", "seasonal", "custom"];
-    o.includes(t.category) || e.push(
-      `Invalid category: "${t.category}". Must be one of: ${o.join(", ")}`
-    );
   }
-  const n = ["primaryColors", "accentColors", "secondaryColors"];
-  for (const o of n)
-    if (t[o]) {
-      const m = t[o], i = [
+  const themeObj = theme;
+  for (const field of REQUIRED_FIELDS) {
+    if (!(field in themeObj) || !themeObj[field]) {
+      errors.push(`Missing required field: ${field}`);
+    }
+  }
+  if (themeObj.id && typeof themeObj.id === "string") {
+    const idRegex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+    if (!idRegex.test(themeObj.id)) {
+      errors.push(
+        `Invalid theme ID format: "${themeObj.id}". Must be kebab-case (e.g., "ocean-blue")`
+      );
+    }
+  }
+  if (themeObj.name && typeof themeObj.name !== "string") {
+    errors.push("Theme name must be a string");
+  }
+  if (themeObj.category) {
+    const validCategories = ["default", "brand", "seasonal", "custom"];
+    if (!validCategories.includes(themeObj.category)) {
+      errors.push(
+        `Invalid category: "${themeObj.category}". Must be one of: ${validCategories.join(", ")}`
+      );
+    }
+  }
+  const colorScaleFields = ["primaryColors", "accentColors", "secondaryColors"];
+  for (const field of colorScaleFields) {
+    if (themeObj[field]) {
+      const scale = themeObj[field];
+      const validKeys = [
         "50",
         "100",
         "200",
@@ -1156,95 +2124,125 @@ function pe(r) {
         "900",
         "950"
       ];
-      for (const a of Object.keys(m))
-        i.includes(a) || s.push(
-          `Invalid color scale key in ${o}: ${a}. Valid keys: ${i.join(", ")}`
-        ), typeof m[a] != "string" && e.push(`Color value in ${o}.${a} must be a string (HSL format)`);
+      for (const key of Object.keys(scale)) {
+        if (!validKeys.includes(key)) {
+          warnings.push(
+            `Invalid color scale key in ${field}: ${key}. Valid keys: ${validKeys.join(", ")}`
+          );
+        }
+        if (typeof scale[key] !== "string") {
+          errors.push(`Color value in ${field}.${key} must be a string (HSL format)`);
+        }
+      }
     }
-  return t.version && typeof t.version == "string" && (/^\d+\.\d+\.\d+$/.test(t.version) || s.push(
-    `Invalid version format: "${t.version}". Should be semver (e.g., "1.0.0")`
-  )), {
-    valid: e.length === 0,
-    errors: e,
-    warnings: s
+  }
+  if (themeObj.version && typeof themeObj.version === "string") {
+    const semverRegex = /^\d+\.\d+\.\d+$/;
+    if (!semverRegex.test(themeObj.version)) {
+      warnings.push(
+        `Invalid version format: "${themeObj.version}". Should be semver (e.g., "1.0.0")`
+      );
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
   };
 }
-function ze(r) {
-  return pe(r).valid;
+function isThemeSchema(obj) {
+  const validation = validateThemeSchema(obj);
+  return validation.valid;
 }
-function Le(r, e) {
+function createMinimalThemeSchema(id, name) {
   return {
-    id: r,
-    name: e,
-    description: `Custom theme: ${e}`,
+    id,
+    name,
+    description: `Custom theme: ${name}`,
     category: "custom",
     version: "1.0.0"
   };
 }
-const Ae = {
+
+// src/theme/loader.ts
+var DEFAULT_OPTIONS = {
   fallbackThemeId: "default",
-  validate: !0,
-  throwOnError: !1
+  validate: true,
+  throwOnError: false
 };
-async function E(r, e = {}) {
-  const s = { ...Ae, ...e }, t = [];
-  if (!C(r)) {
-    if (s.throwOnError)
-      throw new Error(`Theme "${r}" not found`);
-    if (s.fallbackThemeId && C(s.fallbackThemeId))
-      return t.push(`Theme "${r}" not found, using fallback "${s.fallbackThemeId}"`), E(s.fallbackThemeId, { ...s, throwOnError: !1 });
-    throw new Error(`Theme "${r}" not found and no fallback available`);
+async function loadThemeSafe(themeId, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const warnings = [];
+  if (!themeExists(themeId)) {
+    if (opts.throwOnError) {
+      throw new Error(`Theme "${themeId}" not found`);
+    }
+    if (opts.fallbackThemeId && themeExists(opts.fallbackThemeId)) {
+      warnings.push(`Theme "${themeId}" not found, using fallback "${opts.fallbackThemeId}"`);
+      return loadThemeSafe(opts.fallbackThemeId, { ...opts, throwOnError: false });
+    }
+    throw new Error(`Theme "${themeId}" not found and no fallback available`);
   }
   try {
-    const n = await je(r);
-    if (s.validate) {
-      const o = pe(n);
-      if (!o.valid) {
-        if (s.throwOnError)
-          throw new Error(`Theme "${r}" validation failed: ${o.errors.join(", ")}`);
-        if (s.fallbackThemeId && C(s.fallbackThemeId))
-          return t.push(
-            `Theme "${r}" validation failed: ${o.errors.join(", ")}. Using fallback "${s.fallbackThemeId}"`
-          ), E(s.fallbackThemeId, { ...s, throwOnError: !1 });
-        throw new Error(`Theme "${r}" validation failed: ${o.errors.join(", ")}`);
+    const theme = await loadTheme(themeId);
+    if (opts.validate) {
+      const validation = validateThemeSchema(theme);
+      if (!validation.valid) {
+        if (opts.throwOnError) {
+          throw new Error(`Theme "${themeId}" validation failed: ${validation.errors.join(", ")}`);
+        }
+        if (opts.fallbackThemeId && themeExists(opts.fallbackThemeId)) {
+          warnings.push(
+            `Theme "${themeId}" validation failed: ${validation.errors.join(", ")}. Using fallback "${opts.fallbackThemeId}"`
+          );
+          return loadThemeSafe(opts.fallbackThemeId, { ...opts, throwOnError: false });
+        }
+        throw new Error(`Theme "${themeId}" validation failed: ${validation.errors.join(", ")}`);
       }
-      t.push(...o.warnings);
+      warnings.push(...validation.warnings);
     }
     return {
-      theme: n,
-      usedFallback: !1,
-      warnings: t
+      theme,
+      usedFallback: false,
+      warnings
     };
-  } catch (n) {
-    if (s.throwOnError)
-      throw n;
-    if (s.fallbackThemeId && C(s.fallbackThemeId) && s.fallbackThemeId !== r)
-      return t.push(
-        `Failed to load theme "${r}": ${n instanceof Error ? n.message : String(n)}. Using fallback "${s.fallbackThemeId}"`
-      ), E(s.fallbackThemeId, { ...s, throwOnError: !1 });
-    throw n;
+  } catch (error) {
+    if (opts.throwOnError) {
+      throw error;
+    }
+    if (opts.fallbackThemeId && themeExists(opts.fallbackThemeId) && opts.fallbackThemeId !== themeId) {
+      warnings.push(
+        `Failed to load theme "${themeId}": ${error instanceof Error ? error.message : String(error)}. Using fallback "${opts.fallbackThemeId}"`
+      );
+      return loadThemeSafe(opts.fallbackThemeId, { ...opts, throwOnError: false });
+    }
+    throw error;
   }
 }
-async function Ue(r) {
-  const e = r.map(
-    (s) => E(s, { validate: !1, throwOnError: !1 }).catch(() => {
+async function preloadThemes(themeIds) {
+  const loadPromises = themeIds.map(
+    (id) => loadThemeSafe(id, { validate: false, throwOnError: false }).catch(() => {
     })
   );
-  await Promise.all(e);
+  await Promise.all(loadPromises);
 }
-function We() {
-  return de().map((r) => r.id);
+function getAvailableThemeIds() {
+  return getAllThemes().map((theme) => theme.id);
 }
-async function qe(r) {
-  if (!C(r))
-    return !1;
+async function canLoadTheme(themeId) {
+  if (!themeExists(themeId)) {
+    return false;
+  }
   try {
-    return await E(r, { validate: !1, throwOnError: !0 }), !0;
+    await loadThemeSafe(themeId, { validate: false, throwOnError: true });
+    return true;
   } catch {
-    return !1;
+    return false;
   }
 }
-const Ve = {
+
+// src/theme/spacing.ts
+var spacing = {
   none: "0",
   xs: "0.25rem",
   // 4px
@@ -1264,7 +2262,8 @@ const Ve = {
   // 64px
   "5xl": "5rem"
   // 80px
-}, Qe = {
+};
+var borderRadius = {
   none: "0px",
   sm: "0.125rem",
   // 2px
@@ -1281,7 +2280,8 @@ const Ve = {
   "3xl": "1.5rem",
   // 24px
   full: "9999px"
-}, Ge = {
+};
+var shadows = {
   none: "none",
   sm: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
   base: "0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1)",
@@ -1290,174 +2290,241 @@ const Ve = {
   xl: "0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1)",
   "2xl": "0 25px 50px -12px rgb(0 0 0 / 0.25)",
   inner: "inset 0 2px 4px 0 rgb(0 0 0 / 0.05)"
-}, ye = p.createContext(void 0);
-function De(r) {
-  if (r !== void 0) return r;
-  if (typeof window > "u") return !1;
+};
+var ThemeContext = React.createContext(void 0);
+function getInitialReduceMotion(override) {
+  if (override !== void 0) return override;
+  if (typeof window === "undefined") return false;
   try {
     return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
   } catch {
-    return !1;
+    return false;
   }
 }
-function Je({
-  children: r,
-  defaultMode: e = "day",
-  defaultTheme: s = "default",
-  defaultBrand: t = null,
-  storageKey: n = "tm_mode",
-  themeStorageKey: o = "tm_theme",
-  brandStorageKey: m = "tm_brand",
-  attribute: i = "data-mode",
-  enableSystem: a = !0,
-  reduceMotion: c,
-  enableAnimations: x = !0
+function ThemeProvider({
+  children,
+  defaultMode = "day",
+  defaultTheme: defaultTheme2 = "default",
+  defaultBrand = null,
+  storageKey = "tm_mode",
+  themeStorageKey = "tm_theme",
+  brandStorageKey = "tm_brand",
+  attribute = "data-mode",
+  enableSystem = true,
+  reduceMotion: reduceMotionOverride,
+  enableAnimations: enableAnimationsOverride = true
 }) {
-  p.useEffect(() => {
+  React.useEffect(() => {
     try {
-      X($e);
-    } catch (l) {
-      console.warn("Failed to register neon brand:", l);
+      registerBrand(neonBrand);
+    } catch (error) {
+      console.warn("Failed to register neon brand:", error);
     }
     try {
-      X(we);
-    } catch (l) {
-      console.warn("Failed to register minimal brand:", l);
+      registerBrand(minimalBrand);
+    } catch (error) {
+      console.warn("Failed to register minimal brand:", error);
     }
   }, []);
-  const [d, h] = p.useState(() => {
-    if (typeof window > "u") return e;
-    const u = document.documentElement.getAttribute(i);
-    if (u === "day" || u === "night")
-      return u;
+  const [mode, setModeState] = React.useState(() => {
+    if (typeof window === "undefined") return defaultMode;
+    const root = document.documentElement;
+    const existingMode = root.getAttribute(attribute);
+    if (existingMode === "day" || existingMode === "night") {
+      return existingMode;
+    }
     try {
-      const f = localStorage.getItem(n);
-      if (f === "day" || f === "night")
-        return f;
+      const stored = localStorage.getItem(storageKey);
+      if (stored === "day" || stored === "night") {
+        return stored;
+      }
     } catch {
     }
-    return a && typeof window < "u" ? window.matchMedia("(prefers-color-scheme: dark)").matches ? "night" : "day" : e;
-  }), [y, b] = p.useState(() => typeof window > "u" ? s : Z(s, o)), [g, T] = p.useState(() => typeof window > "u" ? t : re(t, m)), [k, B] = p.useState(() => De(c)), [H, _] = p.useState(() => x), P = p.useCallback(
-    (l) => {
-      h(l), $(l, y, g), K(l, n);
+    if (enableSystem && typeof window !== "undefined") {
+      const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+      return prefersDark ? "night" : "day";
+    }
+    return defaultMode;
+  });
+  const [theme, setThemeState] = React.useState(() => {
+    if (typeof window === "undefined") return defaultTheme2;
+    return getInitialTheme(defaultTheme2, themeStorageKey);
+  });
+  const [brand, setBrandState] = React.useState(() => {
+    if (typeof window === "undefined") return defaultBrand;
+    return getInitialBrand(defaultBrand, brandStorageKey);
+  });
+  const [reduceMotion, setReduceMotionState] = React.useState(() => {
+    return getInitialReduceMotion(reduceMotionOverride);
+  });
+  const [enableAnimations, setEnableAnimationsState] = React.useState(() => {
+    return enableAnimationsOverride;
+  });
+  const setMode = React.useCallback(
+    (newMode) => {
+      setModeState(newMode);
+      applyDocumentTheme(newMode, theme, brand);
+      persistMode(newMode, storageKey);
     },
-    [y, g, n]
-  ), N = p.useCallback(
-    async (l) => {
-      b(l), await $(d, l, g), ee(l, o);
+    [theme, brand, storageKey]
+  );
+  const setTheme = React.useCallback(
+    async (newTheme) => {
+      setThemeState(newTheme);
+      await applyDocumentTheme(mode, newTheme, brand);
+      persistTheme(newTheme, themeStorageKey);
     },
-    [d, g, o]
-  ), z = p.useCallback(
-    async (l) => {
-      const u = se();
-      if (u && ie(u.namespace), T(l), te(l, m), l)
+    [mode, brand, themeStorageKey]
+  );
+  const setBrand = React.useCallback(
+    async (brandId) => {
+      const currentBrand = getActiveBrand();
+      if (currentBrand) {
+        removeBrandOverrides(currentBrand.namespace);
+      }
+      setBrandState(brandId);
+      persistBrand(brandId, brandStorageKey);
+      if (brandId) {
         try {
-          const f = await ne(l);
-          ae(f, d);
-        } catch (f) {
-          console.error(`Failed to load brand "${l}":`, f), O(null);
+          const loadedBrand = await loadBrand(brandId);
+          applyBrandOverrides(loadedBrand, mode);
+        } catch (error) {
+          console.error(`Failed to load brand "${brandId}":`, error);
+          setActiveBrand(null);
         }
-      else
-        O(null);
-      await $(d, y, l);
+      } else {
+        setActiveBrand(null);
+      }
+      await applyDocumentTheme(mode, theme, brandId);
     },
-    [d, y, m]
-  ), L = p.useCallback(() => {
-    P(d === "night" ? "day" : "night");
-  }, [d, P]), U = p.useCallback((l) => {
-    B(l);
+    [mode, theme, brandStorageKey]
+  );
+  const toggleMode = React.useCallback(() => {
+    setMode(mode === "night" ? "day" : "night");
+  }, [mode, setMode]);
+  const setReduceMotion = React.useCallback((reduce) => {
+    setReduceMotionState(reduce);
     try {
-      localStorage.setItem("tm_reduce_motion", l ? "true" : "false");
+      localStorage.setItem("tm_reduce_motion", reduce ? "true" : "false");
     } catch {
     }
-  }, []), W = p.useCallback((l) => {
-    _(l);
+  }, []);
+  const setEnableAnimations = React.useCallback((enable) => {
+    setEnableAnimationsState(enable);
     try {
-      localStorage.setItem("tm_enable_animations", l ? "true" : "false");
+      localStorage.setItem("tm_enable_animations", enable ? "true" : "false");
     } catch {
     }
   }, []);
-  p.useEffect(() => {
-    if (c !== void 0) return;
-    const l = window.matchMedia("(prefers-reduced-motion: reduce)"), u = (f) => {
-      B(f.matches);
+  React.useEffect(() => {
+    if (reduceMotionOverride !== void 0) return;
+    const mediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
+    const handleChange = (e) => {
+      setReduceMotionState(e.matches);
     };
-    return l.addEventListener("change", u), () => l.removeEventListener("change", u);
-  }, [c]), p.useEffect(() => {
-    if (c === void 0)
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, [reduceMotionOverride]);
+  React.useEffect(() => {
+    if (reduceMotionOverride === void 0) {
       try {
-        const l = localStorage.getItem("tm_reduce_motion");
-        (l === "true" || l === "false") && B(l === "true");
+        const storedReduceMotion = localStorage.getItem("tm_reduce_motion");
+        if (storedReduceMotion === "true" || storedReduceMotion === "false") {
+          setReduceMotionState(storedReduceMotion === "true");
+        }
       } catch {
       }
-    if (x === void 0)
+    }
+    if (enableAnimationsOverride === void 0) {
       try {
-        const l = localStorage.getItem("tm_enable_animations");
-        (l === "true" || l === "false") && _(l === "true");
+        const storedEnableAnimations = localStorage.getItem("tm_enable_animations");
+        if (storedEnableAnimations === "true" || storedEnableAnimations === "false") {
+          setEnableAnimationsState(storedEnableAnimations === "true");
+        }
       } catch {
       }
-  }, [c, x]), p.useEffect(() => {
-    const l = Se(e, n, a), u = Z(s, o), f = re(t, m);
-    h(l), b(u), T(f), $(l, u, f), K(l, n), ee(u, o), te(f, m);
+    }
+  }, [reduceMotionOverride, enableAnimationsOverride]);
+  React.useEffect(() => {
+    const initialMode = getInitialMode(defaultMode, storageKey, enableSystem);
+    const initialTheme = getInitialTheme(defaultTheme2, themeStorageKey);
+    const initialBrand = getInitialBrand(defaultBrand, brandStorageKey);
+    setModeState(initialMode);
+    setThemeState(initialTheme);
+    setBrandState(initialBrand);
+    applyDocumentTheme(initialMode, initialTheme, initialBrand);
+    persistMode(initialMode, storageKey);
+    persistTheme(initialTheme, themeStorageKey);
+    persistBrand(initialBrand, brandStorageKey);
   }, [
-    e,
-    s,
-    t,
-    n,
-    o,
-    m,
-    a
-  ]), p.useEffect(() => {
-    if (!a) return;
-    const l = window.matchMedia("(prefers-color-scheme: dark)"), u = (f) => {
+    defaultMode,
+    defaultTheme2,
+    defaultBrand,
+    storageKey,
+    themeStorageKey,
+    brandStorageKey,
+    enableSystem
+  ]);
+  React.useEffect(() => {
+    if (!enableSystem) return;
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = (e) => {
       try {
-        localStorage.getItem(n) || P(f.matches ? "night" : "day");
+        const stored = localStorage.getItem(storageKey);
+        if (!stored) {
+          setMode(e.matches ? "night" : "day");
+        }
       } catch {
       }
     };
-    return l.addEventListener("change", u), () => l.removeEventListener("change", u);
-  }, [a, n, P]), p.useEffect(() => {
-    $(d, y, g);
-  }, [d, y, g]);
-  const ue = p.useMemo(
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, [enableSystem, storageKey, setMode]);
+  React.useEffect(() => {
+    applyDocumentTheme(mode, theme, brand);
+  }, [mode, theme, brand]);
+  const value = React.useMemo(
     () => ({
-      mode: d,
-      theme: y,
-      brand: g,
-      reduceMotion: c !== void 0 ? c : k,
-      enableAnimations: x !== void 0 ? x : H,
-      setMode: P,
-      setTheme: N,
-      setBrand: z,
-      toggleMode: L,
-      setReduceMotion: U,
-      setEnableAnimations: W
+      mode,
+      theme,
+      brand,
+      reduceMotion: reduceMotionOverride !== void 0 ? reduceMotionOverride : reduceMotion,
+      enableAnimations: enableAnimationsOverride !== void 0 ? enableAnimationsOverride : enableAnimations,
+      setMode,
+      setTheme,
+      setBrand,
+      toggleMode,
+      setReduceMotion,
+      setEnableAnimations
     }),
     [
-      d,
-      y,
-      g,
-      k,
-      H,
-      c,
-      x,
-      P,
-      N,
-      z,
-      L,
-      U,
-      W
+      mode,
+      theme,
+      brand,
+      reduceMotion,
+      enableAnimations,
+      reduceMotionOverride,
+      enableAnimationsOverride,
+      setMode,
+      setTheme,
+      setBrand,
+      toggleMode,
+      setReduceMotion,
+      setEnableAnimations
     ]
   );
-  return /* @__PURE__ */ be(ye.Provider, { value: ue, children: r });
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value, children });
 }
-function Xe() {
-  const r = p.useContext(ye);
-  if (r === void 0)
+function useTheme() {
+  const context = React.useContext(ThemeContext);
+  if (context === void 0) {
     throw new Error("useTheme must be used within a ThemeProvider");
-  return r;
+  }
+  return context;
 }
-const Ye = {
+
+// src/theme/typography.ts
+var fontFamilies = {
   sans: [
     "ui-sans-serif",
     "system-ui",
@@ -1485,7 +2552,8 @@ const Ye = {
     "Courier New",
     "monospace"
   ].join(", ")
-}, Ze = {
+};
+var fontSizes = {
   xs: "0.75rem",
   // 12px
   sm: "0.875rem",
@@ -1506,7 +2574,8 @@ const Ye = {
   // 48px
   "6xl": "3.75rem"
   // 60px
-}, Ke = {
+};
+var fontWeights = {
   thin: "100",
   extralight: "200",
   light: "300",
@@ -1516,14 +2585,16 @@ const Ye = {
   bold: "700",
   extrabold: "800",
   black: "900"
-}, er = {
+};
+var lineHeights = {
   none: "1",
   tight: "1.25",
   snug: "1.375",
   normal: "1.5",
   relaxed: "1.625",
   loose: "2"
-}, rr = {
+};
+var letterSpacings = {
   tighter: "-0.05em",
   tight: "-0.025em",
   normal: "0em",
@@ -1531,41 +2602,5 @@ const Ye = {
   wider: "0.05em",
   widest: "0.1em"
 };
-export {
-  Je as ThemeProvider,
-  He as applyDocumentMode,
-  $ as applyDocumentTheme,
-  Qe as borderRadius,
-  qe as canLoadTheme,
-  Le as createMinimalThemeSchema,
-  nr as cssVariableColorTokens,
-  Ye as fontFamilies,
-  Ze as fontSizes,
-  Ke as fontWeights,
-  de as getAllThemes,
-  We as getAvailableThemeIds,
-  re as getInitialBrand,
-  Se as getInitialMode,
-  Z as getInitialTheme,
-  _e as getThemeMetadata,
-  Ne as getThemesByCategory,
-  Re as initializeDefaultThemes,
-  ze as isThemeSchema,
-  rr as letterSpacings,
-  er as lineHeights,
-  je as loadTheme,
-  Te as loadThemeOverride,
-  E as loadThemeSafe,
-  te as persistBrand,
-  K as persistMode,
-  ee as persistTheme,
-  Ue as preloadThemes,
-  D as registerTheme,
-  Ge as shadows,
-  Ve as spacing,
-  sr as tailwindThemeColors,
-  C as themeExists,
-  S as themeRegistry,
-  Xe as useTheme,
-  pe as validateThemeSchema
-};
+
+export { ThemeProvider, applyDocumentMode, applyDocumentTheme, borderRadius, canLoadTheme, createMinimalThemeSchema, cssVariableColorTokens, fontFamilies, fontSizes, fontWeights, getAllThemes, getAvailableThemeIds, getInitialBrand, getInitialMode, getInitialTheme, getThemeMetadata, getThemesByCategory, initializeDefaultThemes, isThemeSchema, letterSpacings, lineHeights, loadTheme, loadThemeOverride, loadThemeSafe, persistBrand, persistMode, persistTheme, preloadThemes, registerTheme, shadows, spacing, tailwindThemeColors, themeExists, themeRegistry, useTheme, validateThemeSchema };