maz-ui 4.0.0-beta.33 → 4.0.0-beta.37

package/dist/plugins/maz-ui.js

@@ -1,73 +1,59 @@
-import { reactive, ref } from "vue";
-function parseHSL(hsl) {
-  const match = hsl.match(/^(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)%\s+(\d+(?:\.\d+)?)%$/);
-  if (!match)
-    throw new Error(`Invalid HSL format: ${hsl}`);
+import { reactive } from "vue";
+import { MazUiTranslations } from "@maz-ui/translations";
+function l(n2) {
+  const t2 = n2.match(/^(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)%\s+(\d+(?:\.\d+)?)%$/);
+  if (!t2)
+    throw new Error(`Invalid HSL format: ${n2}`);
   return {
-    h: Number.parseFloat(match[1]),
-    s: Number.parseFloat(match[2]),
-    l: Number.parseFloat(match[3])
+    h: Number.parseFloat(t2[1]),
+    s: Number.parseFloat(t2[2]),
+    l: Number.parseFloat(t2[3])
   };
 }
-function formatHSL(h, s, l) {
-  const roundedH = Math.round(h * 10) / 10, roundedS = Math.round(s * 10) / 10, roundedL = Math.round(l * 10) / 10;
-  return `${roundedH} ${roundedS}% ${roundedL}%`;
+function i(n2, t2, r) {
+  const o2 = Math.round(n2 * 10) / 10, s = Math.round(t2 * 10) / 10, e = Math.round(r * 10) / 10;
+  return `${o2} ${s}% ${e}%`;
 }
-const LUMINOSITY_OFFSETS = {
+const d = {
   50: 37.5,
-  // Base + 50% = very light
   100: 30,
-  // Base + 35% = light
   200: 22.5,
-  // Base + 20% = moderately light
   300: 15,
-  // Base + 10% = slightly lighter
   400: 7.5,
-  // Base + 5% = slightly lighter
   500: 0,
-  // Base (original color)
   600: -7.5,
-  // Base - 5% = slightly darker
   700: -15,
-  // Base - 15% = dark
   800: -22.5,
-  // Base - 20% = very dark
-  900: -30
-  // Base - 25% = extremely dark
+  900: -30,
+  950: -37.5
 };
-function calculateSaturationMultiplier(baseVariant, targetVariant, baseSaturation) {
-  if (targetVariant === baseVariant)
+function p$1(n2, t2, r) {
+  if (t2 === n2)
     return 1;
-  const saturationFactor = Math.min(baseSaturation / 100, 1), variantDiff = Math.abs(targetVariant - baseVariant);
-  if (targetVariant < baseVariant) {
-    const reduction = variantDiff / 500 * 0.25 * saturationFactor;
-    return Math.max(0.3, 1 - reduction);
+  const o2 = Math.min(r / 100, 1), s = Math.abs(t2 - n2);
+  if (t2 < n2) {
+    const e = s / 500 * 0.25 * o2;
+    return Math.max(0.3, 1 - e);
   } else {
-    const increase = variantDiff / 400 * 0.15 * saturationFactor;
-    return Math.min(1.3, 1 + increase);
+    const e = s / 400 * 0.15 * o2;
+    return Math.min(1.3, 1 + e);
   }
 }
-function generateColorScale(baseColor) {
-  const { h, s, l } = parseHSL(baseColor), baseVariant = 500, baseLuminosity = l, variants = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900], scale = {};
-  return variants.forEach((variant) => {
-    if (variant === baseVariant)
-      scale[variant.toString()] = formatHSL(h, s, l);
+function b(n2) {
+  const { h: t2, s: r, l: o2 } = l(n2), s = 500, e = o2, m2 = Object.keys(d).map(Number), u2 = {};
+  return m2.forEach((c2) => {
+    if (c2 === s)
+      u2[c2] = i(t2, r, o2);
     else {
-      const luminosityOffset = LUMINOSITY_OFFSETS[variant];
-      let targetLuminosity = baseLuminosity + luminosityOffset;
-      targetLuminosity = Math.min(95, Math.max(5, targetLuminosity));
-      const saturationMultiplier = calculateSaturationMultiplier(baseVariant, variant, s), adjustedSaturation = Math.min(100, Math.max(5, s * saturationMultiplier));
-      scale[variant.toString()] = formatHSL(h, adjustedSaturation, targetLuminosity);
+      const h2 = c2 < s, f2 = c2 > s, M2 = d[c2];
+      let a;
+      h2 && o2 >= 100 ? a = e : a = e + M2, f2 && o2 <= 0 && (a = 0), a = Math.min(100, Math.max(0, a));
+      const S2 = p$1(s, c2, r), L = Math.min(100, Math.max(5, r * S2));
+      u2[c2] = i(t2, L, a);
     }
-  }), scale;
+  }), u2;
 }
-function getCookie(key) {
-  if (typeof document > "u")
-    return null;
-  const cookie = document.cookie.split(";").find((c) => c.trim().startsWith(`${key}=`));
-  return cookie ? decodeURIComponent(cookie.split("=")[1]) : null;
-}
-const DEFAULT_CRITICAL_COLORS = [
+const h = [
   "background",
   "foreground",
   "primary",
@@ -89,418 +75,270 @@ const DEFAULT_CRITICAL_COLORS = [
   "muted",
   "shadow",
   "border"
-], DEFAULT_CRITICAL_FOUNDATION = [
+], C = [
   "radius",
   "font-family",
   "base-font-size",
   "border-width"
-], scaleColors = ["primary", "secondary", "accent", "destructive", "success", "warning", "info", "contrast", "background", "foreground", "border", "muted", "overlay", "shadow"];
-function generateCriticalCSS(preset, options = {
+], S = ["primary", "secondary", "accent", "destructive", "success", "warning", "info", "contrast", "background", "foreground", "border", "muted", "overlay", "shadow"];
+function j(e, o2 = {
   mode: "both",
   darkSelectorStrategy: "class"
 }) {
   const {
-    criticalColors = DEFAULT_CRITICAL_COLORS,
-    criticalFoundation = DEFAULT_CRITICAL_FOUNDATION,
-    mode,
-    darkSelectorStrategy,
-    prefix = "maz"
-  } = options, foundationCritical = extractCriticalFoundation(preset.foundation, criticalFoundation);
-  let css = `@layer maz-ui-theme {
+    criticalColors: r = h,
+    criticalFoundation: c2 = C,
+    mode: t2,
+    darkSelectorStrategy: s,
+    prefix: i2 = "maz"
+  } = o2, l2 = y(e.foundation, c2);
+  let n2 = `@layer maz-ui-theme {
 `;
-  if (mode === "light" || mode === "both") {
-    const lightCritical = extractCriticalVariables(preset.colors.light, criticalColors);
-    css += generateVariablesBlock({
+  if (t2 === "light" || t2 === "both") {
+    const a = m(e.colors.light, r);
+    n2 += f$1({
       selector: ":root",
-      colors: lightCritical,
-      foundation: foundationCritical,
-      prefix
+      colors: a,
+      foundation: l2,
+      prefix: i2
     });
   }
-  if (mode === "dark" || mode === "both") {
-    const darkCritical = extractCriticalVariables(preset.colors.dark, criticalColors);
-    css += generateVariablesBlock({
-      selector: darkSelectorStrategy === "media" ? ":root" : ".dark",
-      mediaQuery: darkSelectorStrategy === "media" ? "@media (prefers-color-scheme: dark)" : void 0,
-      colors: darkCritical,
-      foundation: foundationCritical,
-      prefix
+  if (t2 === "dark" || t2 === "both") {
+    const a = m(e.colors.dark, r);
+    n2 += f$1({
+      selector: s === "media" ? ":root" : ".dark",
+      mediaQuery: s === "media" ? "@media (prefers-color-scheme: dark)" : void 0,
+      colors: a,
+      foundation: l2,
+      prefix: i2
     });
   }
-  return css += `}
-`, css;
+  return n2 += `}
+`, n2;
 }
-function generateFullCSS(preset, options = {
+function p(e, o2 = {
   mode: "both",
   darkSelectorStrategy: "class"
 }) {
   const {
-    excludeCritical = DEFAULT_CRITICAL_COLORS,
-    mode,
-    darkSelectorStrategy,
-    prefix = "maz",
-    includeColorScales = !0
-  } = options, foundation = excludeFoundationVariables(preset.foundation, DEFAULT_CRITICAL_FOUNDATION);
-  let css = `@layer maz-ui-theme {
+    excludeCritical: r = h,
+    mode: c2,
+    darkSelectorStrategy: t2,
+    prefix: s = "maz",
+    includeColorScales: i2 = !0
+  } = o2, l2 = k$1(e.foundation, C);
+  let n2 = `@layer maz-ui-theme {
 `;
-  if (mode === "light" || mode === "both") {
-    const lightColors = excludeVariables(preset.colors.light, excludeCritical);
-    css += generateVariablesBlock({
+  if (c2 === "light" || c2 === "both") {
+    const a = g$1(e.colors.light, r);
+    n2 += f$1({
       selector: ":root",
-      colors: lightColors,
-      foundation,
-      prefix,
-      includeScales: includeColorScales,
-      preset
+      colors: a,
+      foundation: l2,
+      prefix: s,
+      includeScales: i2,
+      preset: e
     });
   }
-  if (mode === "dark" || mode === "both") {
-    const darkColors = excludeVariables(preset.colors.dark, excludeCritical);
-    css += generateVariablesBlock({
-      selector: darkSelectorStrategy === "media" ? ":root" : ".dark",
-      mediaQuery: darkSelectorStrategy === "media" ? "@media (prefers-color-scheme: dark)" : void 0,
-      colors: darkColors,
-      foundation: mode === "dark" ? foundation : void 0,
+  if (c2 === "dark" || c2 === "both") {
+    const a = g$1(e.colors.dark, r);
+    n2 += f$1({
+      selector: t2 === "media" ? ":root" : ".dark",
+      mediaQuery: t2 === "media" ? "@media (prefers-color-scheme: dark)" : void 0,
+      colors: a,
+      foundation: c2 === "dark" ? l2 : void 0,
       // Appearance only if dark mode only
-      prefix,
-      includeScales: includeColorScales,
-      preset,
+      prefix: s,
+      includeScales: i2,
+      preset: e,
       isDark: !0
     });
   }
-  return css += `}
-`, css;
+  return n2 += `}
+`, n2;
 }
-function extractCriticalVariables(colors, criticalKeys) {
+function m(e, o2) {
   return Object.fromEntries(
-    criticalKeys.filter((key) => colors[key]).map((key) => [key, colors[key]])
+    o2.filter((r) => e[r]).map((r) => [r, e[r]])
   );
 }
-function extractCriticalFoundation(foundation, criticalKeys) {
-  return foundation ? Object.fromEntries(
-    criticalKeys.filter((key) => foundation[key]).map((key) => [key, foundation[key]])
+function y(e, o2) {
+  return e ? Object.fromEntries(
+    o2.filter((r) => e[r]).map((r) => [r, e[r]])
   ) : {};
 }
-function excludeVariables(colors, excludeKeys) {
+function g$1(e, o2) {
   return Object.fromEntries(
-    Object.entries(colors).filter(([key]) => !excludeKeys.includes(key))
+    Object.entries(e).filter(([r]) => !o2.includes(r))
   );
 }
-function excludeFoundationVariables(foundation, excludeKeys) {
-  return foundation ? Object.fromEntries(
-    Object.entries(foundation).filter(([key]) => !excludeKeys.includes(key))
+function k$1(e, o2) {
+  return e ? Object.fromEntries(
+    Object.entries(e).filter(([r]) => !o2.includes(r))
   ) : {};
 }
-function generateVariablesBlock({
-  selector,
-  mediaQuery,
-  colors,
-  foundation,
-  prefix,
-  includeScales = !1,
-  preset,
-  isDark = !1
+function f$1({
+  selector: e,
+  mediaQuery: o2,
+  colors: r,
+  foundation: c2,
+  prefix: t2,
+  includeScales: s = !1,
+  preset: i2,
+  isDark: l2 = !1
 }) {
-  const variables = [];
-  if (colors && Object.entries(colors).forEach(([key, value]) => {
-    value && variables.push(`  --${prefix}-${key}: ${value};`);
-  }), foundation && Object.entries(foundation).forEach(([key, value]) => {
-    value && variables.push(`  --${prefix}-${key}: ${value};`);
-  }), includeScales && preset) {
-    const sourceColors = isDark ? preset.colors.dark : preset.colors.light, colorScales = generateAllColorScales(sourceColors, prefix);
-    variables.push(...colorScales);
+  const n2 = [];
+  if (r && Object.entries(r).forEach(([u2, d2]) => {
+    d2 && n2.push(`  --${t2}-${u2}: ${d2};`);
+  }), c2 && Object.entries(c2).forEach(([u2, d2]) => {
+    d2 && n2.push(`  --${t2}-${u2}: ${d2};`);
+  }), s && i2) {
+    const u2 = l2 ? i2.colors.dark : i2.colors.light, d2 = E(u2, t2);
+    n2.push(...d2);
   }
-  const content = variables.join(`
+  const a = n2.join(`
 `);
-  return mediaQuery ? `
-  ${mediaQuery} {
-    ${selector} {
-${content.replace(/^/gm, "  ")}
+  return o2 ? `
+  ${o2} {
+    ${e} {
+${a.replace(/^/gm, "  ")}
     }
   }
 ` : `
-  ${selector} {
-${content}
+  ${e} {
+${a}
   }
 `;
 }
-function generateAllColorScales(colors, prefix) {
-  const colorScales = [];
-  return scaleColors.forEach((colorName) => {
-    const baseColor = colors[colorName];
-    if (baseColor) {
-      const scale = generateColorScale(baseColor);
-      Object.entries(scale).forEach(([scaleKey, scaleValue]) => {
-        colorScales.push(`  --${prefix}-${colorName}-${scaleKey}: ${scaleValue};`);
+function E(e, o2) {
+  const r = [];
+  return S.forEach((c2) => {
+    const t2 = e[c2];
+    if (t2) {
+      const s = b(t2);
+      Object.entries(s).forEach(([i2, l2]) => {
+        r.push(`  --${o2}-${c2}-${i2}: ${l2};`);
       });
     }
-  }), colorScales;
+  }), r;
 }
-var CSS_IDS = /* @__PURE__ */ ((CSS_IDS2) => (CSS_IDS2.FULL = "maz-theme-full", CSS_IDS2.CRITICAL = "maz-theme-critical", CSS_IDS2))(CSS_IDS || {});
-function injectCSS(id, css) {
+var $ = /* @__PURE__ */ ((e) => (e.FULL = "maz-theme-full", e.CRITICAL = "maz-theme-critical", e))($ || {});
+function v$1(e, o2) {
   if (typeof document > "u")
     return;
-  let styleElement = document.getElementById(id);
-  styleElement || (styleElement = document.createElement("style"), styleElement.id = id, document.head.appendChild(styleElement)), styleElement.textContent = css;
+  let r = document.getElementById(e);
+  r || (r = document.createElement("style"), r.id = e, document.head.appendChild(r)), r.textContent = o2;
+}
+function c(e) {
+  if (typeof document > "u")
+    return null;
+  const t2 = document.cookie.split(";").find((n2) => n2.trim().startsWith(`${e}=`));
+  return t2 ? decodeURIComponent(t2.split("=")[1]) : null;
+}
+function o$1(e) {
+  if (e && ["light", "dark"].includes(e))
+    return e;
+  const t2 = c("maz-color-mode");
+  return t2 && ["light", "dark"].includes(t2) ? t2 : "auto";
 }
-function isPresetObject(preset) {
-  return typeof preset == "object" && preset !== null && !!preset.name;
+function n() {
+  return typeof globalThis.window < "u" && typeof globalThis.matchMedia == "function" && globalThis.matchMedia("(prefers-color-scheme: dark)").matches;
 }
-async function getPreset(preset) {
-  if (isPresetObject(preset))
-    return preset;
-  if (preset === "mazUi" || !preset || preset === "maz-ui") {
-    const { mazUi } = await import("../chunks/mazUi.D6UdqpTO.js");
-    return mazUi;
+function t(i2) {
+  return typeof i2 == "object" && i2 !== null && !!i2.name;
+}
+async function o(i2) {
+  if (t(i2))
+    return i2;
+  if (i2 === "mazUi" || !i2 || i2 === "maz-ui") {
+    const { mazUi: n2 } = await import("../chunks/mazUi.0b7z2u9g.js");
+    return n2;
   }
-  if (preset === "ocean") {
-    const { ocean } = await import("../chunks/ocean.pHrY5H_S.js");
-    return ocean;
+  if (i2 === "ocean") {
+    const { ocean: n2 } = await import("../chunks/ocean.ehMlC0HV.js");
+    return n2;
   }
-  if (preset === "pristine") {
-    const { pristine } = await import("../chunks/pristine.CxBZzgUG.js");
-    return pristine;
+  if (i2 === "pristine") {
+    const { pristine: n2 } = await import("../chunks/pristine.DMG3eBuN.js");
+    return n2;
   }
-  if (preset === "obsidian") {
-    const { obsidian } = await import("../chunks/obsidian.Cy0R8RHy.js");
-    return obsidian;
+  if (i2 === "obsidian") {
+    const { obsidian: n2 } = await import("../chunks/obsidian.C6upWOVF.js");
+    return n2;
   }
-  throw new TypeError(`[@maz-ui/themes] Preset ${preset} not found`);
+  throw new TypeError(`[@maz-ui/themes] Preset ${i2} not found`);
 }
-function mergePresets(base, overrides) {
+function f(n2, o2) {
   return {
-    name: overrides.name || base.name,
+    name: o2.name || n2.name,
     foundation: {
-      ...base.foundation,
-      ...overrides.foundation
+      ...n2.foundation,
+      ...o2.foundation
     },
     colors: {
-      light: mergeColors(base.colors.light, overrides.colors?.light),
-      dark: mergeColors(base.colors.dark, overrides.colors?.dark)
+      light: u(n2.colors.light, o2.colors?.light),
+      dark: u(n2.colors.dark, o2.colors?.dark)
     }
   };
 }
-function mergeColors(base, overrides) {
-  return overrides ? {
-    ...base,
-    ...overrides
-  } : base;
+function u(n2, o2) {
+  return o2 ? {
+    ...n2,
+    ...o2
+  } : n2;
 }
-function getColorMode(colorMode) {
-  if (colorMode && ["light", "dark"].includes(colorMode))
-    return colorMode;
-  const savedMode = getCookie("maz-color-mode");
-  return savedMode && ["light", "dark"].includes(savedMode) ? savedMode : "auto";
+function g(r, t2) {
+  typeof document > "u" || r !== "class" || (t2 ? document.documentElement.classList.add("dark") : document.documentElement.classList.remove("dark"));
 }
-function isSystemPrefersDark() {
-  return typeof globalThis.window < "u" && typeof globalThis.matchMedia == "function" && globalThis.matchMedia("(prefers-color-scheme: dark)").matches;
-}
-function applyDarkMode(darkModeStrategy, isDark) {
-  typeof document > "u" || darkModeStrategy !== "class" || (isDark ? document.documentElement.classList.add("dark") : document.documentElement.classList.remove("dark"));
-}
-function injectThemeCSS(finalPreset, config) {
+function k(r, t2) {
   if (typeof document > "u")
     return;
-  const cssOptions = {
-    mode: config.mode,
-    darkSelectorStrategy: config.darkModeStrategy
+  const e = {
+    mode: t2.mode,
+    darkSelectorStrategy: t2.darkModeStrategy
   };
-  if (config.injectCriticalCSS) {
-    const criticalCSS = generateCriticalCSS(finalPreset, cssOptions);
-    injectCSS(CSS_IDS.CRITICAL, criticalCSS);
+  if (t2.injectCriticalCSS) {
+    const a = j(r, e);
+    v$1($.CRITICAL, a);
   }
-  if (!config.injectFullCSS)
+  if (!t2.injectFullCSS)
     return;
-  const fullCSS = generateFullCSS(finalPreset, cssOptions);
-  config.strategy === "runtime" ? injectCSS(CSS_IDS.FULL, fullCSS) : config.strategy === "hybrid" && requestIdleCallback(() => {
-    injectCSS(CSS_IDS.FULL, fullCSS);
+  const o2 = p(r, e);
+  t2.strategy === "runtime" ? v$1($.FULL, o2) : t2.strategy === "hybrid" && requestIdleCallback(() => {
+    v$1($.FULL, o2);
   }, { timeout: 100 });
 }
-function injectThemeState(app, themeState) {
-  app.provide("mazThemeState", themeState), app.config.globalProperties.$mazThemeState = themeState;
+function M(r, t2) {
+  r.provide("mazThemeState", t2), r.config.globalProperties.$mazThemeState = t2;
 }
-const MazUiTheme = {
-  async install(app, options = {}) {
-    const config = {
-      preset: "maz-ui",
+const v = {
+  async install(r, t2) {
+    const e = {
       strategy: "runtime",
       overrides: {},
       darkModeStrategy: "class",
-      colorMode: (options.mode !== "both" ? options.mode : options.colorMode) ?? "auto",
+      colorMode: (t2?.mode !== "both" ? t2?.mode : t2?.colorMode) ?? "auto",
       injectCriticalCSS: !0,
       injectFullCSS: !0,
       mode: "both",
-      ...options
-    }, colorMode = config.mode !== "both" ? config.mode : getColorMode(config.colorMode), isDark = colorMode === "auto" && config.mode === "both" ? isSystemPrefersDark() : colorMode === "dark" || config.mode === "dark", themeState = reactive({
+      ...t2
+    }, o$2 = e.mode !== "both" ? e.mode : o$1(e.colorMode), a = o$2 === "auto" && e.mode === "both" ? n() : o$2 === "dark" || e.mode === "dark", s = reactive({
       // @ts-expect-error - empty currentPreset to avoid error
       currentPreset: {},
-      mode: config.mode,
-      colorMode,
-      isDark,
-      strategy: config.strategy,
-      darkModeStrategy: config.darkModeStrategy
+      mode: e.mode,
+      colorMode: o$2,
+      isDark: a,
+      strategy: e.strategy,
+      darkModeStrategy: e.darkModeStrategy
     });
-    applyDarkMode(config.darkModeStrategy, isDark), injectThemeState(app, themeState);
-    const preset = await getPreset(config.preset), finalPreset = Object.keys(config.overrides).length > 0 ? mergePresets(preset, config.overrides) : preset;
-    themeState.currentPreset = finalPreset, config.strategy !== "buildtime" && injectThemeCSS(finalPreset, config);
-  }
-}, defaultLocalesLoaders = {
-  "./locales/de.ts": () => import("../chunks/de.B15Maq8Z.js").then((m) => ({ default: m.default })),
-  "./locales/en.ts": () => import("../chunks/en.Q_4-KljL.js").then((m) => ({ default: m.default })),
-  "./locales/es.ts": () => import("../chunks/es.BV1TlfTw.js").then((m) => ({ default: m.default })),
-  "./locales/fr.ts": () => import("../chunks/fr.BVPG-7Dk.js").then((m) => ({ default: m.default })),
-  "./locales/it.ts": () => import("../chunks/it.Be9xhI4P.js").then((m) => ({ default: m.default })),
-  "./locales/ja.ts": () => import("../chunks/ja.CWU7KYEA.js").then((m) => ({ default: m.default })),
-  "./locales/pt.ts": () => import("../chunks/pt.CfaFSxVt.js").then((m) => ({ default: m.default })),
-  "./locales/zh-CN.ts": () => import("../chunks/zh-CN.CCkuvk-E.js").then((m) => ({ default: m.default }))
-}, defaultMessagesCache = /* @__PURE__ */ new Map(), globalState = reactive({
-  loadedLocales: /* @__PURE__ */ new Set(),
-  messages: {},
-  userMessages: {},
-  loadingPromises: /* @__PURE__ */ new Map()
-});
-function getMessage(obj, path) {
-  return path.split(".").reduce((current, key) => current?.[key], obj);
-}
-function setMessage(obj, path, value) {
-  const keys = path.split("."), lastKey = keys.pop(), target = keys.reduce((current, key) => ((!current[key] || typeof current[key] != "object") && (current[key] = {}), current[key]), obj);
-  target[lastKey] = value;
-}
-function isFlattenedObject(obj) {
-  return !obj || typeof obj != "object" ? !1 : Object.keys(obj).some((key) => key.includes("."));
-}
-function flattenToNested(flatObj) {
-  if (!isFlattenedObject(flatObj))
-    return flatObj;
-  const nested = {};
-  for (const [key, value] of Object.entries(flatObj))
-    key.includes(".") ? setMessage(nested, key, value) : nested[key] = value;
-  return nested;
-}
-function mergeMessages(target, source) {
-  const normalizedSource = flattenToNested(source), result = { ...flattenToNested(target) };
-  for (const key in normalizedSource)
-    normalizedSource[key] && typeof normalizedSource[key] == "object" ? result[key] = mergeMessages(result[key] || {}, normalizedSource[key]) : result[key] = normalizedSource[key];
-  return result;
-}
-function interpolate(message, variables) {
-  return variables ? message.replace(/\{(\w+)\}/g, (match, key) => variables[key] !== void 0 ? String(variables[key]) : match) : message;
-}
-async function loadDefaultMessages(locale) {
-  if (defaultMessagesCache.has(locale))
-    return defaultMessagesCache.get(locale);
-  const loaderPath = `./locales/${locale}.ts`, loader = defaultLocalesLoaders[loaderPath];
-  if (!loader)
-    return {};
-  try {
-    const messages = (await loader()).default;
-    return defaultMessagesCache.set(locale, messages), messages;
-  } catch (error) {
-    return console.error(`Failed to load default messages for locale "${locale}":`, error), {};
-  }
-}
-function loadLocale(targetLocale) {
-  if (globalState.loadedLocales.has(targetLocale))
-    return Promise.resolve();
-  if (globalState.loadingPromises.has(targetLocale))
-    return globalState.loadingPromises.get(targetLocale);
-  const loadingPromise = (async () => {
-    try {
-      const localeDefaultMessages = await loadDefaultMessages(targetLocale);
-      let localeUserMessages = {};
-      const userLoader = globalState.userMessages[targetLocale];
-      if (userLoader)
-        if (typeof userLoader == "function")
-          try {
-            const userMessages = await userLoader();
-            localeUserMessages = "default" in userMessages ? userMessages.default : userMessages;
-          } catch (error) {
-            console.error(`Failed to load user translations for locale "${targetLocale}":`, error), localeUserMessages = {};
-          }
-        else
-          localeUserMessages = userLoader;
-      globalState.messages[targetLocale] = mergeMessages(localeDefaultMessages, localeUserMessages), globalState.loadedLocales.add(targetLocale);
-    } catch (error) {
-      console.error(`Failed to load translations for locale "${targetLocale}":`, error), globalState.messages[targetLocale] = {}, globalState.loadedLocales.add(targetLocale);
-    } finally {
-      globalState.loadingPromises.delete(targetLocale);
-    }
-  })();
-  return globalState.loadingPromises.set(targetLocale, loadingPromise), loadingPromise;
-}
-function createMazTranslations(options = {}) {
-  const {
-    locale: initialLocale = "en",
-    fallbackLocale = "en",
-    preloadFallback = !0,
-    messages = {}
-  } = options, locale = ref(initialLocale);
-  for (const [loc, msgs] of Object.entries(messages))
-    globalState.userMessages[loc] = msgs, msgs && typeof msgs == "object" && (globalState.messages[loc] = { ...globalState.messages[loc], ...msgs });
-  setTimeout(() => {
-    loadLocale(initialLocale).catch(console.error), preloadFallback && fallbackLocale !== initialLocale && loadLocale(fallbackLocale).catch(console.error);
-  }, 0);
-  function t(key, variables) {
-    let message = getMessage(globalState.messages[locale.value], key);
-    if (!message && fallbackLocale && locale.value !== fallbackLocale) {
-      if (!globalState.loadedLocales.has(fallbackLocale))
-        return loadLocale(fallbackLocale).catch(console.error), key;
-      message = getMessage(globalState.messages[fallbackLocale], key);
-    }
-    if (!message && fallbackLocale !== "en" && locale.value !== "en") {
-      if (!globalState.loadedLocales.has("en"))
-        return loadLocale("en").catch(console.error), key;
-      message = getMessage(globalState.messages.en, key);
-    }
-    return message ? interpolate(String(message), variables) : (console.warn(`[@maz-ui/translations] Translation not found for key: ${key}`), key);
-  }
-  async function setLocale(newLocale) {
-    globalState.loadedLocales.has(newLocale) || await loadLocale(newLocale), locale.value = newLocale;
-  }
-  function isLocaleLoaded(localeToCheck) {
-    return globalState.loadedLocales.has(localeToCheck);
-  }
-  function isLocaleLoading(localeToCheck) {
-    return globalState.loadingPromises.has(localeToCheck);
-  }
-  function getAvailableLocales() {
-    const locales = /* @__PURE__ */ new Set();
-    for (const [path, loader] of Object.entries(defaultLocalesLoaders))
-      loader && typeof loader == "function" && locales.add(path.replace("./locales/", "").replace(".ts", ""));
-    for (const path of Object.keys(globalState.userMessages))
-      locales.add(path);
-    return Array.from(locales);
-  }
-  function getMessages() {
-    return globalState.messages;
-  }
-  function getLoadedLocales() {
-    return Object.keys(globalState.messages);
-  }
-  function setLocaleMessage(targetLocale, messages2) {
-    globalState.messages[targetLocale] || (globalState.messages[targetLocale] = {}), globalState.messages[targetLocale] = mergeMessages(globalState.messages[targetLocale], messages2), globalState.loadedLocales.add(targetLocale);
-  }
-  return {
-    locale,
-    t,
-    setLocale,
-    isLocaleLoaded,
-    isLocaleLoading,
-    getAvailableLocales,
-    setLocaleMessage,
-    getMessages,
-    getLoadedLocales
-  };
-}
-const MazTranslations = {
-  install(app, options = {}) {
-    const i18n = createMazTranslations(options);
-    return app.config.globalProperties.$mazTranslations = i18n, app.provide("mazTranslations", i18n), i18n;
+    g(e.darkModeStrategy, a), M(r, s);
+    const c2 = await o(e.preset), m2 = Object.keys(e.overrides).length > 0 ? f(c2, e.overrides) : c2;
+    s.currentPreset = m2, e.strategy !== "buildtime" && k(m2, e);
   }
 }, MazUi = {
-  install(app, options = {}) {
+  install(app, options) {
     const { theme, translations } = options;
-    app.use(MazUiTheme, theme), app.use(MazTranslations, translations);
+    app.use(v, theme), app.use(MazUiTranslations, translations);
   }
 };
 export {