@gjfleo/theme 0.2.0 → 0.2.2

package/dist/naive-ui/index.js

@@ -98,8 +98,8 @@ var require_unwrap_element = __commonJS((exports) => {
 var require_happens_in = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.happensIn = happensIn;
-  function happensIn(e, dataSetPropName) {
-    let { target } = e;
+  function happensIn(e2, dataSetPropName) {
+    let { target } = e2;
     while (target) {
       if (target.dataset) {
         if (target.dataset[dataSetPropName] !== undefined)
@@ -521,8 +521,8 @@ var require_color = __commonJS((exports) => {
         return [roundDeg(i[1]), roundPercent(i[5]), roundPercent(i[9]), 1];
       }
       throw new Error(`[seemly/hsla]: Invalid color value ${color}.`);
-    } catch (e) {
-      throw e;
+    } catch (e2) {
+      throw e2;
     }
   }
   function hsva(color) {
@@ -539,8 +539,8 @@ var require_color = __commonJS((exports) => {
         return [roundDeg(i[1]), roundPercent(i[5]), roundPercent(i[9]), 1];
       }
       throw new Error(`[seemly/hsva]: Invalid color value ${color}.`);
-    } catch (e) {
-      throw e;
+    } catch (e2) {
+      throw e2;
     }
   }
   function rgba(color) {
@@ -588,8 +588,8 @@ var require_color = __commonJS((exports) => {
         return [...(0, convert_1.hsv2rgb)(h, s, v), a];
       }
       throw new Error(`[seemly/rgba]: Invalid color value ${color}.`);
-    } catch (e) {
-      throw e;
+    } catch (e2) {
+      throw e2;
     }
   }
   function normalizeAlpha(alphaValue) {
@@ -931,25 +931,1273 @@ var require_lib = __commonJS((exports) => {
   } });
 });
 
-// src/naive-ui/theme-overrides-dark.ts
-var theme_overrides_dark_default = {
-  common: {
-    fontFamily: "var(--default-font-family)",
-    fontFamilyMono: "var(--default-monoFont-family)",
-    fontWeight: "var(--fontWeight-normal)",
-    fontWeightStrong: "var(--fontWeight-medium)",
-    borderRadius: "var(--radius-DEFAULT)",
-    borderRadiusSmall: "var(--radius-xs)",
-    fontSize: "var(--text-base-fontSize)",
-    fontSizeMini: "var(--text-xs-fontSize)",
-    fontSizeTiny: "var(--text-xs-fontSize)",
-    fontSizeSmall: "var(--text-sm-fontSize)",
-    fontSizeMedium: "var(--text-base-fontSize)",
-    fontSizeLarge: "var(--text-lg-fontSize)",
-    fontSizeHuge: "var(--text-xl-fontSize)",
-    lineHeight: "1.5"
+// node_modules/@unocss/core/dist/index.mjs
+var LAYER_DEFAULT = "default";
+var LAYER_PREFLIGHTS = "preflights";
+var LAYER_SHORTCUTS = "shortcuts";
+var LAYER_IMPORTS = "imports";
+var DEFAULT_LAYERS = {
+  [LAYER_IMPORTS]: -200,
+  [LAYER_PREFLIGHTS]: -100,
+  [LAYER_SHORTCUTS]: -10,
+  [LAYER_DEFAULT]: 0
+};
+var defaultSplitRE = /[\\:]?[\s'"`;{}]+/g;
+function splitCode(code) {
+  return code.split(defaultSplitRE);
+}
+var extractorSplit = {
+  name: "@unocss/core/extractor-split",
+  order: 0,
+  extract({ code }) {
+    return splitCode(code);
   }
 };
+function toArray(value = []) {
+  return Array.isArray(value) ? value : [value];
+}
+function uniq(value) {
+  return Array.from(new Set(value));
+}
+function uniqueBy(array, equalFn) {
+  return array.reduce((acc, cur) => {
+    const index = acc.findIndex((item) => equalFn(cur, item));
+    if (index === -1)
+      acc.push(cur);
+    return acc;
+  }, []);
+}
+function isString(s) {
+  return typeof s === "string";
+}
+
+class CountableSet extends Set {
+  _map = /* @__PURE__ */ new Map;
+  constructor(values) {
+    super();
+    if (values) {
+      for (const key of values) {
+        this.add(key);
+      }
+    }
+  }
+  add(key) {
+    this._map.set(key, (this._map.get(key) ?? 0) + 1);
+    return super.add(key);
+  }
+  delete(key) {
+    if (!this._map.has(key)) {
+      return false;
+    }
+    this._map.delete(key);
+    return super.delete(key);
+  }
+  clear() {
+    this._map.clear();
+    super.clear();
+  }
+  getCount(key) {
+    return this._map.get(key) ?? 0;
+  }
+  setCount(key, count) {
+    this._map.set(key, count);
+    return super.add(key);
+  }
+}
+function isCountableSet(value) {
+  return value instanceof CountableSet;
+}
+function escapeSelector(str) {
+  const length = str.length;
+  let index = -1;
+  let codeUnit;
+  let result = "";
+  const firstCodeUnit = str.charCodeAt(0);
+  while (++index < length) {
+    codeUnit = str.charCodeAt(index);
+    if (codeUnit === 0) {
+      result += "�";
+      continue;
+    }
+    if (codeUnit === 37) {
+      result += "\\%";
+      continue;
+    }
+    if (codeUnit === 44) {
+      result += "\\,";
+      continue;
+    }
+    if (codeUnit >= 1 && codeUnit <= 31 || codeUnit === 127 || index === 0 && codeUnit >= 48 && codeUnit <= 57 || index === 1 && codeUnit >= 48 && codeUnit <= 57 && firstCodeUnit === 45) {
+      result += `\\${codeUnit.toString(16)} `;
+      continue;
+    }
+    if (index === 0 && length === 1 && codeUnit === 45) {
+      result += `\\${str.charAt(index)}`;
+      continue;
+    }
+    if (codeUnit >= 128 || codeUnit === 45 || codeUnit === 95 || codeUnit >= 48 && codeUnit <= 57 || codeUnit >= 65 && codeUnit <= 90 || codeUnit >= 97 && codeUnit <= 122) {
+      result += str.charAt(index);
+      continue;
+    }
+    result += `\\${str.charAt(index)}`;
+  }
+  return result;
+}
+var e = escapeSelector;
+function createNanoEvents() {
+  return {
+    events: {},
+    emit(event, ...args) {
+      (this.events[event] || []).forEach((i) => i(...args));
+    },
+    on(event, cb) {
+      (this.events[event] = this.events[event] || []).push(cb);
+      return () => this.events[event] = (this.events[event] || []).filter((i) => i !== cb);
+    }
+  };
+}
+function normalizeVariant(variant) {
+  return typeof variant === "function" ? { match: variant } : variant;
+}
+function isRawUtil(util) {
+  return util.length === 3;
+}
+function notNull(value) {
+  return value != null;
+}
+function noop() {}
+class TwoKeyMap {
+  _map = /* @__PURE__ */ new Map;
+  get(key1, key2) {
+    const m2 = this._map.get(key1);
+    if (m2)
+      return m2.get(key2);
+  }
+  getFallback(key1, key2, fallback) {
+    let m2 = this._map.get(key1);
+    if (!m2) {
+      m2 = /* @__PURE__ */ new Map;
+      this._map.set(key1, m2);
+    }
+    if (!m2.has(key2))
+      m2.set(key2, fallback);
+    return m2.get(key2);
+  }
+  set(key1, key2, value) {
+    let m2 = this._map.get(key1);
+    if (!m2) {
+      m2 = /* @__PURE__ */ new Map;
+      this._map.set(key1, m2);
+    }
+    m2.set(key2, value);
+    return this;
+  }
+  has(key1, key2) {
+    return this._map.get(key1)?.has(key2);
+  }
+  delete(key1, key2) {
+    return this._map.get(key1)?.delete(key2) || false;
+  }
+  deleteTop(key1) {
+    return this._map.delete(key1);
+  }
+  map(fn) {
+    return Array.from(this._map.entries()).flatMap(([k1, m2]) => Array.from(m2.entries()).map(([k2, v]) => {
+      return fn(v, k1, k2);
+    }));
+  }
+}
+
+class BetterMap extends Map {
+  getFallback(key, fallback) {
+    const v = this.get(key);
+    if (v === undefined) {
+      this.set(key, fallback);
+      return fallback;
+    }
+    return v;
+  }
+  map(mapFn) {
+    const result = [];
+    this.forEach((v, k) => {
+      result.push(mapFn(v, k));
+    });
+    return result;
+  }
+  flatMap(mapFn) {
+    const result = [];
+    this.forEach((v, k) => {
+      result.push(...mapFn(v, k));
+    });
+    return result;
+  }
+}
+function normalizeCSSEntries(obj) {
+  if (isString(obj))
+    return obj;
+  return (!Array.isArray(obj) ? Object.entries(obj) : obj).filter((i) => i[1] != null);
+}
+function normalizeCSSValues(obj) {
+  if (Array.isArray(obj)) {
+    if (obj.find((i) => !Array.isArray(i) || Array.isArray(i[0])))
+      return obj.map((i) => normalizeCSSEntries(i));
+    else
+      return [obj];
+  } else {
+    return [normalizeCSSEntries(obj)];
+  }
+}
+function clearIdenticalEntries(entry) {
+  return entry.filter(([k, v], idx) => {
+    if (k.startsWith("$$"))
+      return false;
+    for (let i = idx - 1;i >= 0; i--) {
+      if (entry[i][0] === k && entry[i][1] === v)
+        return false;
+    }
+    return true;
+  });
+}
+function entriesToCss(arr) {
+  if (arr == null)
+    return "";
+  return clearIdenticalEntries(arr).map(([key, value]) => value != null && typeof value !== "function" ? `${key}:${value};` : undefined).filter(Boolean).join("");
+}
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+function mergeDeep(original, patch, mergeArray = false) {
+  const o = original;
+  const p = patch;
+  if (Array.isArray(p)) {
+    if (mergeArray && Array.isArray(p))
+      return [...o, ...p];
+    else
+      return [...p];
+  }
+  const output = { ...o };
+  if (isObject(o) && isObject(p)) {
+    Object.keys(p).forEach((key) => {
+      if (isObject(o[key]) && isObject(p[key]) || Array.isArray(o[key]) && Array.isArray(p[key]))
+        output[key] = mergeDeep(o[key], p[key], mergeArray);
+      else
+        Object.assign(output, { [key]: p[key] });
+    });
+  }
+  return output;
+}
+function clone(val) {
+  let k, out, tmp;
+  if (Array.isArray(val)) {
+    out = Array.from({ length: k = val.length });
+    while (k--)
+      out[k] = (tmp = val[k]) && typeof tmp === "object" ? clone(tmp) : tmp;
+    return out;
+  }
+  if (Object.prototype.toString.call(val) === "[object Object]") {
+    out = {};
+    for (k in val) {
+      if (k === "__proto__") {
+        Object.defineProperty(out, k, {
+          value: clone(val[k]),
+          configurable: true,
+          enumerable: true,
+          writable: true
+        });
+      } else {
+        out[k] = (tmp = val[k]) && typeof tmp === "object" ? clone(tmp) : tmp;
+      }
+    }
+    return out;
+  }
+  return val;
+}
+function isStaticRule(rule) {
+  return isString(rule[0]);
+}
+function isStaticShortcut(sc) {
+  return isString(sc[0]);
+}
+var regexCache = {};
+function makeRegexClassGroup(separators = ["-", ":"]) {
+  const key = separators.join("|");
+  if (!regexCache[key])
+    regexCache[key] = new RegExp(`((?:[!@<~\\w+:_-]|\\[&?>?:?\\S*\\])+?)(${key})\\(((?:[~!<>\\w\\s:/\\\\,%#.$?-]|\\[[^\\]]*?\\])+?)\\)(?!\\s*?=>)`, "gm");
+  regexCache[key].lastIndex = 0;
+  return regexCache[key];
+}
+function parseVariantGroup(str, separators = ["-", ":"], depth = 5) {
+  const regexClassGroup = makeRegexClassGroup(separators);
+  let hasChanged;
+  let content = str.toString();
+  const prefixes = /* @__PURE__ */ new Set;
+  const groupsByOffset = /* @__PURE__ */ new Map;
+  do {
+    hasChanged = false;
+    content = content.replace(regexClassGroup, (from, pre, sep, body, groupOffset) => {
+      if (!separators.includes(sep))
+        return from;
+      hasChanged = true;
+      prefixes.add(pre + sep);
+      const bodyOffset = groupOffset + pre.length + sep.length + 1;
+      const group = { length: from.length, items: [] };
+      groupsByOffset.set(groupOffset, group);
+      for (const itemMatch of [...body.matchAll(/\S+/g)]) {
+        const itemOffset = bodyOffset + itemMatch.index;
+        let innerItems = groupsByOffset.get(itemOffset)?.items;
+        if (innerItems) {
+          groupsByOffset.delete(itemOffset);
+        } else {
+          innerItems = [{
+            offset: itemOffset,
+            length: itemMatch[0].length,
+            className: itemMatch[0]
+          }];
+        }
+        for (const item of innerItems) {
+          item.className = item.className === "~" ? pre : item.className.replace(/^(!?)(.*)/, `$1${pre}${sep}$2`);
+          group.items.push(item);
+        }
+      }
+      return "$".repeat(from.length);
+    });
+    depth -= 1;
+  } while (hasChanged && depth);
+  let expanded;
+  if (typeof str === "string") {
+    expanded = "";
+    let prevOffset = 0;
+    for (const [offset, group] of groupsByOffset) {
+      expanded += str.slice(prevOffset, offset);
+      expanded += group.items.map((item) => item.className).join(" ");
+      prevOffset = offset + group.length;
+    }
+    expanded += str.slice(prevOffset);
+  } else {
+    expanded = str;
+    for (const [offset, group] of groupsByOffset) {
+      expanded.overwrite(offset, offset + group.length, group.items.map((item) => item.className).join(" "));
+    }
+  }
+  return {
+    prefixes: Array.from(prefixes),
+    hasChanged,
+    groupsByOffset,
+    get expanded() {
+      return expanded.toString();
+    }
+  };
+}
+function expandVariantGroup(str, separators = ["-", ":"], depth = 5) {
+  const res = parseVariantGroup(str, separators, depth);
+  return typeof str === "string" ? res.expanded : str;
+}
+var warned = /* @__PURE__ */ new Set;
+function warnOnce(msg) {
+  if (warned.has(msg))
+    return;
+  console.warn("[unocss]", msg);
+  warned.add(msg);
+}
+function resolveShortcuts(shortcuts) {
+  return toArray(shortcuts).flatMap((s) => {
+    if (Array.isArray(s))
+      return [s];
+    return Object.entries(s);
+  });
+}
+var __RESOLVED = "_uno_resolved";
+async function resolvePreset(presetInput) {
+  let preset = typeof presetInput === "function" ? await presetInput() : await presetInput;
+  if (__RESOLVED in preset)
+    return preset;
+  preset = { ...preset };
+  Object.defineProperty(preset, __RESOLVED, {
+    value: true,
+    enumerable: false
+  });
+  const shortcuts = preset.shortcuts ? resolveShortcuts(preset.shortcuts) : undefined;
+  preset.shortcuts = shortcuts;
+  if (preset.prefix || preset.layer) {
+    const apply = (i) => {
+      if (!i[2])
+        i[2] = {};
+      const meta = i[2];
+      if (meta.prefix == null && preset.prefix)
+        meta.prefix = toArray(preset.prefix);
+      if (meta.layer == null && preset.layer)
+        meta.layer = preset.layer;
+    };
+    shortcuts?.forEach(apply);
+    preset.rules?.forEach(apply);
+  }
+  return preset;
+}
+async function resolvePresets(preset) {
+  const root = await resolvePreset(preset);
+  if (!root.presets)
+    return [root];
+  const nested = (await Promise.all((root.presets || []).flatMap(toArray).flatMap(resolvePresets))).flat();
+  return [root, ...nested];
+}
+function mergeContentOptions(optionsArray) {
+  if (optionsArray.length === 0) {
+    return {};
+  }
+  const pipelineIncludes = [];
+  const pipelineExcludes = [];
+  let pipelineDisabled = false;
+  const filesystem = [];
+  const inline = [];
+  const plain = [];
+  for (const options of optionsArray) {
+    if (options.pipeline === false) {
+      pipelineDisabled = true;
+      break;
+    } else {
+      if (options.pipeline?.include) {
+        pipelineIncludes.push(options.pipeline.include);
+      }
+      if (options.pipeline?.exclude) {
+        pipelineExcludes.push(options.pipeline.exclude);
+      }
+    }
+    if (options.filesystem) {
+      filesystem.push(options.filesystem);
+    }
+    if (options.inline) {
+      inline.push(options.inline);
+    }
+    if (options.plain) {
+      plain.push(options.plain);
+    }
+  }
+  const mergedContent = {
+    pipeline: pipelineDisabled ? false : {
+      include: uniq(mergeFilterPatterns(...pipelineIncludes)),
+      exclude: uniq(mergeFilterPatterns(...pipelineExcludes))
+    }
+  };
+  if (filesystem.length) {
+    mergedContent.filesystem = uniq(filesystem.flat());
+  }
+  if (inline.length) {
+    mergedContent.inline = uniq(inline.flat());
+  }
+  if (plain.length) {
+    mergedContent.plain = uniq(plain.flat());
+  }
+  return mergedContent;
+}
+async function resolveConfig(userConfig = {}, defaults = {}) {
+  const config = Object.assign({}, defaults, userConfig);
+  const rawPresets = uniqueBy((await Promise.all((config.presets || []).flatMap(toArray).flatMap(resolvePresets))).flat(), (a, b) => a.name === b.name);
+  const sortedPresets = [
+    ...rawPresets.filter((p) => p.enforce === "pre"),
+    ...rawPresets.filter((p) => !p.enforce),
+    ...rawPresets.filter((p) => p.enforce === "post")
+  ];
+  const sources = [
+    ...sortedPresets,
+    config
+  ];
+  const sourcesReversed = [...sources].reverse();
+  const layers = Object.assign({}, DEFAULT_LAYERS, ...sources.map((i) => i.layers));
+  function getMerged(key) {
+    return uniq(sources.flatMap((p) => toArray(p[key] || [])));
+  }
+  const extractors = getMerged("extractors");
+  let extractorDefault = sourcesReversed.find((i) => i.extractorDefault !== undefined)?.extractorDefault;
+  if (extractorDefault === undefined)
+    extractorDefault = extractorSplit;
+  if (extractorDefault && !extractors.includes(extractorDefault))
+    extractors.unshift(extractorDefault);
+  extractors.sort((a, b) => (a.order || 0) - (b.order || 0));
+  const rules = getMerged("rules");
+  const rulesStaticMap = {};
+  const rulesSize = rules.length;
+  const rulesDynamic = rules.filter((rule) => {
+    if (!isStaticRule(rule))
+      return true;
+    const prefixes = toArray(rule[2]?.prefix || "");
+    prefixes.forEach((prefix) => {
+      rulesStaticMap[prefix + rule[0]] = rule;
+    });
+    return false;
+  }).reverse();
+  let theme = mergeThemes(sources.map((p) => p.theme));
+  const extendThemes = getMerged("extendTheme");
+  for (const extendTheme of extendThemes)
+    theme = extendTheme(theme) || theme;
+  const autocomplete = {
+    templates: uniq(sources.flatMap((p) => toArray(p.autocomplete?.templates))),
+    extractors: sources.flatMap((p) => toArray(p.autocomplete?.extractors)).sort((a, b) => (a.order || 0) - (b.order || 0)),
+    shorthands: mergeAutocompleteShorthands(sources.map((p) => p.autocomplete?.shorthands || {}))
+  };
+  let separators = getMerged("separators");
+  if (!separators.length)
+    separators = [":", "-"];
+  const contents = getMerged("content");
+  const content = mergeContentOptions(contents);
+  const resolved = {
+    mergeSelectors: true,
+    warn: true,
+    sortLayers: (layers2) => layers2,
+    ...config,
+    blocklist: getMerged("blocklist"),
+    presets: sortedPresets,
+    envMode: config.envMode || "build",
+    shortcutsLayer: config.shortcutsLayer || "shortcuts",
+    layers,
+    theme,
+    rules,
+    rulesSize,
+    rulesDynamic,
+    rulesStaticMap,
+    preprocess: getMerged("preprocess"),
+    postprocess: getMerged("postprocess"),
+    preflights: getMerged("preflights"),
+    autocomplete,
+    variants: getMerged("variants").map(normalizeVariant).sort((a, b) => (a.order || 0) - (b.order || 0)),
+    shortcuts: resolveShortcuts(getMerged("shortcuts")).reverse(),
+    extractors,
+    safelist: getMerged("safelist"),
+    separators,
+    details: config.details ?? config.envMode === "dev",
+    content,
+    transformers: uniqueBy(getMerged("transformers"), (a, b) => a.name === b.name)
+  };
+  for (const p of sources)
+    p?.configResolved?.(resolved);
+  return resolved;
+}
+function mergeThemes(themes) {
+  return themes.map((theme) => theme ? clone(theme) : {}).reduce((a, b) => mergeDeep(a, b), {});
+}
+function mergeAutocompleteShorthands(shorthands) {
+  return shorthands.reduce((a, b) => {
+    const rs = {};
+    for (const key in b) {
+      const value = b[key];
+      if (Array.isArray(value))
+        rs[key] = `(${value.join("|")})`;
+      else
+        rs[key] = value;
+    }
+    return {
+      ...a,
+      ...rs
+    };
+  }, {});
+}
+function mergeFilterPatterns(...filterPatterns) {
+  return filterPatterns.flatMap(flatternFilterPattern);
+}
+function flatternFilterPattern(pattern) {
+  return Array.isArray(pattern) ? pattern : pattern ? [pattern] : [];
+}
+var version = "66.2.1";
+var symbols = {
+  shortcutsNoMerge: "$$symbol-shortcut-no-merge",
+  noMerge: "$$symbol-no-merge",
+  variants: "$$symbol-variants",
+  parent: "$$symbol-parent",
+  selector: "$$symbol-selector",
+  layer: "$$symbol-layer",
+  sort: "$$symbol-sort"
+};
+
+class UnoGeneratorInternal {
+  constructor(userConfig = {}, defaults = {}) {
+    this.userConfig = userConfig;
+    this.defaults = defaults;
+  }
+  version = version;
+  events = createNanoEvents();
+  config = undefined;
+  cache = /* @__PURE__ */ new Map;
+  blocked = /* @__PURE__ */ new Set;
+  parentOrders = /* @__PURE__ */ new Map;
+  activatedRules = /* @__PURE__ */ new Set;
+  static async create(userConfig = {}, defaults = {}) {
+    const uno = new UnoGeneratorInternal(userConfig, defaults);
+    uno.config = await resolveConfig(uno.userConfig, uno.defaults);
+    uno.events.emit("config", uno.config);
+    return uno;
+  }
+  async setConfig(userConfig, defaults) {
+    if (!userConfig)
+      return;
+    if (defaults)
+      this.defaults = defaults;
+    this.userConfig = userConfig;
+    this.blocked.clear();
+    this.parentOrders.clear();
+    this.activatedRules.clear();
+    this.cache.clear();
+    this.config = await resolveConfig(userConfig, this.defaults);
+    this.events.emit("config", this.config);
+  }
+  async applyExtractors(code, id, extracted = /* @__PURE__ */ new Set) {
+    const context = {
+      original: code,
+      code,
+      id,
+      extracted,
+      envMode: this.config.envMode
+    };
+    for (const extractor of this.config.extractors) {
+      const result = await extractor.extract?.(context);
+      if (!result)
+        continue;
+      if (isCountableSet(result) && isCountableSet(extracted)) {
+        for (const token of result)
+          extracted.setCount(token, extracted.getCount(token) + result.getCount(token));
+      } else {
+        for (const token of result)
+          extracted.add(token);
+      }
+    }
+    return extracted;
+  }
+  makeContext(raw, applied) {
+    const context = {
+      rawSelector: raw,
+      currentSelector: applied[1],
+      theme: this.config.theme,
+      generator: this,
+      symbols,
+      variantHandlers: applied[2],
+      constructCSS: (...args) => this.constructCustomCSS(context, ...args),
+      variantMatch: applied
+    };
+    return context;
+  }
+  async parseToken(raw, alias) {
+    if (this.blocked.has(raw))
+      return;
+    const cacheKey = `${raw}${alias ? ` ${alias}` : ""}`;
+    if (this.cache.has(cacheKey))
+      return this.cache.get(cacheKey);
+    let current = raw;
+    for (const p of this.config.preprocess)
+      current = p(raw);
+    if (this.isBlocked(current)) {
+      this.blocked.add(raw);
+      this.cache.set(cacheKey, null);
+      return;
+    }
+    const variantResults = await this.matchVariants(raw, current);
+    if (variantResults.every((i) => !i || this.isBlocked(i[1]))) {
+      this.blocked.add(raw);
+      this.cache.set(cacheKey, null);
+      return;
+    }
+    const handleVariantResult = async (matched) => {
+      const context = this.makeContext(raw, [alias || matched[0], matched[1], matched[2], matched[3]]);
+      if (this.config.details)
+        context.variants = [...matched[3]];
+      const expanded = await this.expandShortcut(context.currentSelector, context);
+      const utils = expanded ? await this.stringifyShortcuts(context.variantMatch, context, expanded[0], expanded[1]) : (await this.parseUtil(context.variantMatch, context))?.map((i) => this.stringifyUtil(i, context)).filter(notNull);
+      return utils;
+    };
+    const result = (await Promise.all(variantResults.map((i) => handleVariantResult(i)))).flat().filter((x) => !!x);
+    if (result?.length) {
+      this.cache.set(cacheKey, result);
+      return result;
+    }
+    this.cache.set(cacheKey, null);
+  }
+  async generate(input, options = {}) {
+    const {
+      id,
+      scope,
+      preflights = true,
+      safelist = true,
+      minify = false,
+      extendedInfo = false
+    } = options;
+    const tokens = isString(input) ? await this.applyExtractors(input, id, extendedInfo ? new CountableSet : /* @__PURE__ */ new Set) : Array.isArray(input) ? new Set(input) : input;
+    if (safelist) {
+      const safelistContext = {
+        generator: this,
+        theme: this.config.theme
+      };
+      this.config.safelist.flatMap((s) => typeof s === "function" ? s(safelistContext) : s).forEach((s) => {
+        const trimedS = s.trim();
+        if (trimedS && !tokens.has(trimedS))
+          tokens.add(trimedS);
+      });
+    }
+    const nl = minify ? "" : `
+`;
+    const layerSet = /* @__PURE__ */ new Set([LAYER_DEFAULT]);
+    const matched = extendedInfo ? /* @__PURE__ */ new Map : /* @__PURE__ */ new Set;
+    const sheet = /* @__PURE__ */ new Map;
+    let preflightsMap = {};
+    const tokenPromises = Array.from(tokens).map(async (raw) => {
+      if (matched.has(raw))
+        return;
+      const payload = await this.parseToken(raw);
+      if (payload == null)
+        return;
+      if (matched instanceof Map) {
+        matched.set(raw, {
+          data: payload,
+          count: isCountableSet(tokens) ? tokens.getCount(raw) : -1
+        });
+      } else {
+        matched.add(raw);
+      }
+      for (const item of payload) {
+        const parent = item[3] || "";
+        const layer = item[4]?.layer;
+        if (!sheet.has(parent))
+          sheet.set(parent, []);
+        sheet.get(parent).push(item);
+        if (layer)
+          layerSet.add(layer);
+      }
+    });
+    await Promise.all(tokenPromises);
+    await (async () => {
+      if (!preflights)
+        return;
+      const preflightContext = {
+        generator: this,
+        theme: this.config.theme
+      };
+      const preflightLayerSet = /* @__PURE__ */ new Set([]);
+      this.config.preflights.forEach(({ layer = LAYER_PREFLIGHTS }) => {
+        layerSet.add(layer);
+        preflightLayerSet.add(layer);
+      });
+      preflightsMap = Object.fromEntries(await Promise.all(Array.from(preflightLayerSet).map(async (layer) => {
+        const preflights2 = await Promise.all(this.config.preflights.filter((i) => (i.layer || LAYER_PREFLIGHTS) === layer).map(async (i) => await i.getCSS(preflightContext)));
+        const css = preflights2.filter(Boolean).join(nl);
+        return [layer, css];
+      })));
+    })();
+    const layers = this.config.sortLayers(Array.from(layerSet).sort((a, b) => (this.config.layers[a] ?? 0) - (this.config.layers[b] ?? 0) || a.localeCompare(b)));
+    const layerCache = {};
+    const outputCssLayers = this.config.outputToCssLayers;
+    const getLayerAlias = (layer) => {
+      let alias = layer;
+      if (typeof outputCssLayers === "object") {
+        alias = outputCssLayers.cssLayerName?.(layer);
+      }
+      return alias === null ? null : alias ?? layer;
+    };
+    const getLayer = (layer = LAYER_DEFAULT) => {
+      if (layerCache[layer])
+        return layerCache[layer];
+      let css = Array.from(sheet).sort((a, b) => (this.parentOrders.get(a[0]) ?? 0) - (this.parentOrders.get(b[0]) ?? 0) || a[0]?.localeCompare(b[0] || "") || 0).map(([parent, items]) => {
+        const size = items.length;
+        const sorted = items.filter((i) => (i[4]?.layer || LAYER_DEFAULT) === layer).sort((a, b) => {
+          return a[0] - b[0] || (a[4]?.sort || 0) - (b[4]?.sort || 0) || a[5]?.currentSelector?.localeCompare(b[5]?.currentSelector ?? "") || a[1]?.localeCompare(b[1] || "") || a[2]?.localeCompare(b[2] || "") || 0;
+        }).map(([, selector, body, , meta, , variantNoMerge]) => {
+          const scopedSelector = selector ? applyScope(selector, scope) : selector;
+          return [
+            [[scopedSelector ?? "", meta?.sort ?? 0]],
+            body,
+            !!(variantNoMerge ?? meta?.noMerge)
+          ];
+        });
+        if (!sorted.length)
+          return;
+        const ruleLines = sorted.reverse().map(([selectorSortPair, body, noMerge], idx) => {
+          if (!noMerge && this.config.mergeSelectors) {
+            for (let i = idx + 1;i < size; i++) {
+              const current = sorted[i];
+              if (current && !current[2] && (selectorSortPair && current[0] || selectorSortPair == null && current[0] == null) && current[1] === body) {
+                if (selectorSortPair && current[0])
+                  current[0].push(...selectorSortPair);
+                return null;
+              }
+            }
+          }
+          const selectors = selectorSortPair ? uniq(selectorSortPair.sort((a, b) => a[1] - b[1] || a[0]?.localeCompare(b[0] || "") || 0).map((pair) => pair[0]).filter(Boolean)) : [];
+          return selectors.length ? `${selectors.join(`,${nl}`)}{${body}}` : body;
+        }).filter(Boolean);
+        const rules = Array.from(new Set(ruleLines)).reverse().join(nl);
+        if (!parent)
+          return rules;
+        const parents = parent.split(" $$ ");
+        return `${parents.join("{")}{${nl}${rules}${nl}${"}".repeat(parents.length)}`;
+      }).filter(Boolean).join(nl);
+      if (preflights) {
+        css = [preflightsMap[layer], css].filter(Boolean).join(nl);
+      }
+      let alias;
+      if (outputCssLayers && css) {
+        alias = getLayerAlias(layer);
+        if (alias !== null) {
+          css = `@layer ${alias}{${nl}${css}${nl}}`;
+        }
+      }
+      const layerMark = minify ? "" : `/* layer: ${layer}${alias && alias !== layer ? `, alias: ${alias}` : ""} */${nl}`;
+      return layerCache[layer] = css ? layerMark + css : "";
+    };
+    const getLayers = (includes = layers, excludes) => {
+      const layers2 = includes.filter((i) => !excludes?.includes(i));
+      return [
+        outputCssLayers && layers2.length > 0 ? `@layer ${layers2.map(getLayerAlias).filter(notNull).join(", ")};` : undefined,
+        ...layers2.map((i) => getLayer(i) || "")
+      ].filter(Boolean).join(nl);
+    };
+    const setLayer = async (layer, callback) => {
+      const content = await callback(getLayer(layer));
+      layerCache[layer] = content;
+      return content;
+    };
+    return {
+      get css() {
+        return getLayers();
+      },
+      layers,
+      matched,
+      getLayers,
+      getLayer,
+      setLayer
+    };
+  }
+  async matchVariants(raw, current) {
+    const context = {
+      rawSelector: raw,
+      theme: this.config.theme,
+      generator: this
+    };
+    const match = async (result) => {
+      let applied = true;
+      const [, , handlers, variants] = result;
+      while (applied) {
+        applied = false;
+        const processed = result[1];
+        for (const v of this.config.variants) {
+          if (!v.multiPass && variants.has(v))
+            continue;
+          let handler = await v.match(processed, context);
+          if (!handler)
+            continue;
+          if (isString(handler)) {
+            if (handler === processed)
+              continue;
+            handler = { matcher: handler };
+          }
+          if (Array.isArray(handler)) {
+            if (!handler.length)
+              continue;
+            if (handler.length === 1) {
+              handler = handler[0];
+            } else {
+              if (v.multiPass)
+                throw new Error("multiPass can not be used together with array return variants");
+              const clones = handler.map((h) => {
+                const _processed = h.matcher ?? processed;
+                const _handlers = [h, ...handlers];
+                const _variants = new Set(variants);
+                _variants.add(v);
+                return [result[0], _processed, _handlers, _variants];
+              });
+              return (await Promise.all(clones.map((c) => match(c)))).flat();
+            }
+          }
+          result[1] = handler.matcher ?? processed;
+          handlers.unshift(handler);
+          variants.add(v);
+          applied = true;
+          break;
+        }
+        if (!applied)
+          break;
+        if (handlers.length > 500)
+          throw new Error(`Too many variants applied to "${raw}"`);
+      }
+      return [result];
+    };
+    return await match([
+      raw,
+      current || raw,
+      [],
+      /* @__PURE__ */ new Set
+    ]);
+  }
+  applyVariants(parsed, variantHandlers = parsed[4], raw = parsed[1]) {
+    const handler = variantHandlers.slice().sort((a, b) => (a.order || 0) - (b.order || 0)).reduceRight((previous, v) => (input) => {
+      const entries = v.body?.(input.entries) || input.entries;
+      const parents = Array.isArray(v.parent) ? v.parent : [v.parent, undefined];
+      const selector = v.selector?.(input.selector, entries);
+      return (v.handle ?? defaultVariantHandler)({
+        ...input,
+        entries,
+        selector: selector || input.selector,
+        parent: parents[0] || input.parent,
+        parentOrder: parents[1] || input.parentOrder,
+        layer: v.layer || input.layer,
+        sort: v.sort || input.sort
+      }, previous);
+    }, (input) => input);
+    const variantContextResult = handler({
+      prefix: "",
+      selector: toEscapedSelector(raw),
+      pseudo: "",
+      entries: parsed[2]
+    });
+    const { parent, parentOrder } = variantContextResult;
+    if (parent != null && parentOrder != null)
+      this.parentOrders.set(parent, parentOrder);
+    const obj = {
+      selector: [
+        variantContextResult.prefix,
+        variantContextResult.selector,
+        variantContextResult.pseudo
+      ].join(""),
+      entries: variantContextResult.entries,
+      parent,
+      layer: variantContextResult.layer,
+      sort: variantContextResult.sort,
+      noMerge: variantContextResult.noMerge
+    };
+    for (const p of this.config.postprocess)
+      p(obj);
+    return obj;
+  }
+  constructCustomCSS(context, body, overrideSelector) {
+    const normalizedBody = normalizeCSSEntries(body);
+    if (isString(normalizedBody))
+      return normalizedBody;
+    const { selector, entries, parent } = this.applyVariants([0, overrideSelector || context.rawSelector, normalizedBody, undefined, context.variantHandlers]);
+    const cssBody = `${selector}{${entriesToCss(entries)}}`;
+    if (parent)
+      return `${parent}{${cssBody}}`;
+    return cssBody;
+  }
+  async parseUtil(input, context, internal = false, shortcutPrefix) {
+    const variantResults = isString(input) ? await this.matchVariants(input) : [input];
+    const parse = async ([raw, processed, variantHandlers]) => {
+      if (this.config.details)
+        context.rules = context.rules ?? [];
+      const staticMatch = this.config.rulesStaticMap[processed];
+      if (staticMatch) {
+        if (staticMatch[1] && (internal || !staticMatch[2]?.internal)) {
+          if (this.config.details)
+            context.rules.push(staticMatch);
+          const index = this.config.rules.indexOf(staticMatch);
+          const entries = normalizeCSSValues(staticMatch[1]).filter((i) => i.length);
+          const meta = staticMatch[2];
+          if (entries.length) {
+            context.generator.activatedRules.add(staticMatch);
+            return entries.map((css) => {
+              if (isString(css))
+                return [index, css, meta];
+              return [index, raw, css, meta, variantHandlers];
+            });
+          }
+        }
+      }
+      context.variantHandlers = variantHandlers;
+      const { rulesDynamic } = this.config;
+      for (const rule of rulesDynamic) {
+        const [matcher, handler, meta] = rule;
+        if (meta?.internal && !internal)
+          continue;
+        let unprefixed = processed;
+        if (meta?.prefix) {
+          const prefixes = toArray(meta.prefix);
+          if (shortcutPrefix) {
+            const shortcutPrefixes = toArray(shortcutPrefix);
+            if (!prefixes.some((i) => shortcutPrefixes.includes(i)))
+              continue;
+          } else {
+            const prefix = prefixes.find((i) => processed.startsWith(i));
+            if (prefix == null)
+              continue;
+            unprefixed = processed.slice(prefix.length);
+          }
+        }
+        const match = unprefixed.match(matcher);
+        if (!match)
+          continue;
+        let result = await handler(match, context);
+        if (!result)
+          continue;
+        if (this.config.details)
+          context.rules.push(rule);
+        if (typeof result !== "string") {
+          if (Symbol.asyncIterator in result) {
+            const entries2 = [];
+            for await (const r of result) {
+              if (r)
+                entries2.push(r);
+            }
+            result = entries2;
+          } else if (Symbol.iterator in result && !Array.isArray(result)) {
+            result = Array.from(result).filter(notNull);
+          }
+        }
+        const entries = normalizeCSSValues(result).filter((i) => i.length);
+        if (entries.length) {
+          context.generator.activatedRules.add(rule);
+          const index = this.config.rules.indexOf(rule);
+          return entries.map((css) => {
+            if (isString(css))
+              return [index, css, meta];
+            let variants = variantHandlers;
+            let entryMeta = meta;
+            for (const entry of css) {
+              if (entry[0] === symbols.variants) {
+                if (typeof entry[1] === "function") {
+                  variants = entry[1](variants) || variants;
+                } else {
+                  variants = [
+                    ...toArray(entry[1]),
+                    ...variants
+                  ];
+                }
+              } else if (entry[0] === symbols.parent) {
+                variants = [
+                  { parent: entry[1] },
+                  ...variants
+                ];
+              } else if (entry[0] === symbols.selector) {
+                variants = [
+                  { selector: entry[1] },
+                  ...variants
+                ];
+              } else if (entry[0] === symbols.layer) {
+                variants = [
+                  { layer: entry[1] },
+                  ...variants
+                ];
+              } else if (entry[0] === symbols.sort) {
+                entryMeta = {
+                  ...entryMeta,
+                  sort: entry[1]
+                };
+              } else if (entry[0] === symbols.noMerge) {
+                entryMeta = {
+                  ...entryMeta,
+                  noMerge: entry[1]
+                };
+              }
+            }
+            return [index, raw, css, entryMeta, variants];
+          });
+        }
+      }
+    };
+    const parsed = (await Promise.all(variantResults.map((i) => parse(i)))).flat().filter((x) => !!x);
+    if (!parsed.length)
+      return;
+    return parsed;
+  }
+  stringifyUtil(parsed, context) {
+    if (!parsed)
+      return;
+    if (isRawUtil(parsed))
+      return [parsed[0], undefined, parsed[1], undefined, parsed[2], this.config.details ? context : undefined, undefined];
+    const {
+      selector,
+      entries,
+      parent,
+      layer: variantLayer,
+      sort: variantSort,
+      noMerge
+    } = this.applyVariants(parsed);
+    const body = entriesToCss(entries);
+    if (!body)
+      return;
+    const { layer: metaLayer, sort: metaSort, ...meta } = parsed[3] ?? {};
+    const ruleMeta = {
+      ...meta,
+      layer: variantLayer ?? metaLayer,
+      sort: variantSort ?? metaSort
+    };
+    return [parsed[0], selector, body, parent, ruleMeta, this.config.details ? context : undefined, noMerge];
+  }
+  async expandShortcut(input, context, depth = 5) {
+    if (depth === 0)
+      return;
+    const recordShortcut = this.config.details ? (s) => {
+      context.shortcuts = context.shortcuts ?? [];
+      context.shortcuts.push(s);
+    } : noop;
+    let meta;
+    let result;
+    let stringResult;
+    let inlineResult;
+    for (const s of this.config.shortcuts) {
+      let unprefixed = input;
+      if (s[2]?.prefix) {
+        const prefixes = toArray(s[2].prefix);
+        const prefix = prefixes.find((i) => input.startsWith(i));
+        if (prefix == null)
+          continue;
+        unprefixed = input.slice(prefix.length);
+      }
+      if (isStaticShortcut(s)) {
+        if (s[0] === unprefixed) {
+          meta = meta || s[2];
+          result = s[1];
+          recordShortcut(s);
+          break;
+        }
+      } else {
+        const match = unprefixed.match(s[0]);
+        if (match)
+          result = s[1](match, context);
+        if (result) {
+          meta = meta || s[2];
+          recordShortcut(s);
+          break;
+        }
+      }
+    }
+    if (result) {
+      stringResult = uniq(toArray(result).filter(isString).map((s) => expandVariantGroup(s.trim()).split(/\s+/g)).flat());
+      inlineResult = toArray(result).filter((i) => !isString(i)).map((i) => ({ handles: [], value: i }));
+    }
+    if (!result) {
+      const matched = isString(input) ? await this.matchVariants(input) : [input];
+      for (const match of matched) {
+        const [raw, inputWithoutVariant, handles] = match;
+        if (raw !== inputWithoutVariant) {
+          const expanded = await this.expandShortcut(inputWithoutVariant, context, depth - 1);
+          if (expanded) {
+            stringResult = expanded[0].filter(isString).map((item) => raw.replace(inputWithoutVariant, item));
+            inlineResult = expanded[0].filter((i) => !isString(i)).map((item) => {
+              return { handles: [...item.handles, ...handles], value: item.value };
+            });
+          }
+        }
+      }
+    }
+    if (!stringResult?.length && !inlineResult?.length)
+      return;
+    return [
+      [
+        await Promise.all(toArray(stringResult).map(async (s) => (await this.expandShortcut(s, context, depth - 1))?.[0] || [s])),
+        inlineResult
+      ].flat(2).filter((x) => !!x),
+      meta
+    ];
+  }
+  async stringifyShortcuts(parent, context, expanded, meta = { layer: this.config.shortcutsLayer }) {
+    const layerMap = new BetterMap;
+    const parsed = (await Promise.all(uniq(expanded).map(async (i) => {
+      const result = isString(i) ? await this.parseUtil(i, context, true, meta.prefix) : [[Number.POSITIVE_INFINITY, "{inline}", normalizeCSSEntries(i.value), undefined, i.handles]];
+      if (!result && this.config.warn)
+        warnOnce(`unmatched utility "${i}" in shortcut "${parent[1]}"`);
+      return result || [];
+    }))).flat(1).filter(Boolean).sort((a, b) => a[0] - b[0]);
+    const [raw, , parentVariants] = parent;
+    const rawStringifiedUtil = [];
+    for (const item of parsed) {
+      if (isRawUtil(item)) {
+        rawStringifiedUtil.push([item[0], undefined, item[1], undefined, item[2], context, undefined]);
+        continue;
+      }
+      const { selector, entries, parent: parent2, sort, noMerge, layer } = this.applyVariants(item, [...item[4], ...parentVariants], raw);
+      const selectorMap = layerMap.getFallback(layer ?? meta.layer, new TwoKeyMap);
+      const mapItem = selectorMap.getFallback(selector, parent2, [[], item[0]]);
+      mapItem[0].push([entries, !!(noMerge ?? item[3]?.noMerge), sort ?? 0]);
+    }
+    return rawStringifiedUtil.concat(layerMap.flatMap((selectorMap, layer) => selectorMap.map(([e2, index], selector, joinedParents) => {
+      const stringify = (flatten, noMerge, entrySortPair) => {
+        const maxSort = Math.max(...entrySortPair.map((e3) => e3[1]));
+        const entriesList = entrySortPair.map((e3) => e3[0]);
+        return (flatten ? [entriesList.flat(1)] : entriesList).map((entries) => {
+          const body = entriesToCss(entries);
+          if (body)
+            return [index, selector, body, joinedParents, { ...meta, noMerge, sort: maxSort, layer }, context, undefined];
+          return;
+        });
+      };
+      const merges = [
+        [e2.filter(([, noMerge]) => noMerge).map(([entries, , sort]) => [entries, sort]), true],
+        [e2.filter(([, noMerge]) => !noMerge).map(([entries, , sort]) => [entries, sort]), false]
+      ];
+      return merges.map(([e3, noMerge]) => [
+        ...stringify(false, noMerge, e3.filter(([entries]) => entries.some((entry) => entry[0] === symbols.shortcutsNoMerge))),
+        ...stringify(true, noMerge, e3.filter(([entries]) => entries.every((entry) => entry[0] !== symbols.shortcutsNoMerge)))
+      ]);
+    }).flat(2).filter(Boolean)));
+  }
+  isBlocked(raw) {
+    return !raw || this.config.blocklist.map((e2) => Array.isArray(e2) ? e2[0] : e2).some((e2) => typeof e2 === "function" ? e2(raw) : isString(e2) ? e2 === raw : e2.test(raw));
+  }
+  getBlocked(raw) {
+    const rule = this.config.blocklist.find((e2) => {
+      const v = Array.isArray(e2) ? e2[0] : e2;
+      return typeof v === "function" ? v(raw) : isString(v) ? v === raw : v.test(raw);
+    });
+    return rule ? Array.isArray(rule) ? rule : [rule, undefined] : undefined;
+  }
+}
+var regexScopePlaceholder = /\s\$\$\s+/g;
+function hasScopePlaceholder(css) {
+  return regexScopePlaceholder.test(css);
+}
+function applyScope(css, scope) {
+  if (hasScopePlaceholder(css))
+    return css.replace(regexScopePlaceholder, scope ? ` ${scope} ` : " ");
+  else
+    return scope ? `${scope} ${css}` : css;
+}
+var attributifyRe = /^\[(.+?)(~?=)"(.*)"\]$/;
+function toEscapedSelector(raw) {
+  if (attributifyRe.test(raw))
+    return raw.replace(attributifyRe, (_, n, s, i) => `[${e(n)}${s}"${e(i)}"]`);
+  return `.${e(raw)}`;
+}
+function defaultVariantHandler(input, next) {
+  return next(input);
+}
+
+// src/naive-ui/theme-overrides-shared.ts
+function getThemeOverridesShared(options = {}) {
+  const { unocss = true } = options;
+  if (unocss) {
+    return {
+      common: {
+        fontFamily: "var(--default-font-family)",
+        fontFamilyMono: "var(--default-monoFont-family)",
+        fontWeight: "var(--fontWeight-normal)",
+        fontWeightStrong: "var(--fontWeight-medium)",
+        borderRadius: "var(--radius-DEFAULT)",
+        borderRadiusSmall: "var(--radius-xs)",
+        fontSize: "var(--text-base-fontSize)",
+        fontSizeMini: "var(--text-xs-fontSize)",
+        fontSizeTiny: "var(--text-xs-fontSize)",
+        fontSizeSmall: "var(--text-sm-fontSize)",
+        fontSizeMedium: "var(--text-base-fontSize)",
+        fontSizeLarge: "var(--text-lg-fontSize)",
+        fontSizeHuge: "var(--text-xl-fontSize)",
+        lineHeight: "1.5",
+        textColorBase: "var(--colors-dark-400)",
+        textColor1: "var(--colors-dark-200)",
+        textColor2: "var(--colors-dark-50)",
+        textColor3: "var(--colors-gray-500)",
+        textColorDisabled: "var(--colors-gray-400)"
+      },
+      Card: {
+        color: "var(--colors-light-400)",
+        colorEmbedded: "var(--colors-light-50)",
+        borderColor: "var(--colors-gray-200)"
+      }
+    };
+  } else {
+    return {};
+  }
+}
+
+// src/naive-ui/theme-overrides-dark.ts
+function getThemeOverridesDark(options = {}) {
+  const shared = getThemeOverridesShared(options);
+  const dark = {};
+  return mergeDeep(shared, dark);
+}
+var themeOverridesDark = getThemeOverridesDark();
 // src/theme-variables.ts
 var import_seemly = __toESM(require_lib(), 1);
 function createHoverColor(color, overlayAlpha = 0.15) {
@@ -980,59 +2228,43 @@ var themeVariables = {
   dangerHover: createHoverColor("#E7000B"),
   dangerPressed: createPressedColor("#E7000B")
 };
-var theme_variables_default = themeVariables;
 
 // src/naive-ui/theme-overrides-light.ts
-var theme_overrides_light_default = {
-  common: {
-    fontFamily: "var(--default-font-family)",
-    fontFamilyMono: "var(--default-monoFont-family)",
-    fontWeight: "var(--fontWeight-normal)",
-    fontWeightStrong: "var(--fontWeight-medium)",
-    borderRadius: "var(--radius-DEFAULT)",
-    borderRadiusSmall: "var(--radius-xs)",
-    primaryColor: theme_variables_default.primary,
-    primaryColorHover: theme_variables_default.primaryHover,
-    primaryColorPressed: theme_variables_default.primaryPressed,
-    primaryColorSuppl: theme_variables_default.primary,
-    infoColor: theme_variables_default.info,
-    infoColorHover: theme_variables_default.infoHover,
-    infoColorPressed: theme_variables_default.infoPressed,
-    infoColorSuppl: theme_variables_default.info,
-    successColor: theme_variables_default.success,
-    successColorHover: theme_variables_default.successHover,
-    successColorPressed: theme_variables_default.successPressed,
-    successColorSuppl: theme_variables_default.success,
-    warningColor: theme_variables_default.warning,
-    warningColorHover: theme_variables_default.warningHover,
-    warningColorPressed: theme_variables_default.warningPressed,
-    warningColorSuppl: theme_variables_default.warning,
-    errorColor: theme_variables_default.danger,
-    errorColorHover: theme_variables_default.dangerHover,
-    errorColorPressed: theme_variables_default.dangerPressed,
-    errorColorSuppl: theme_variables_default.danger,
-    fontSize: "var(--text-base-fontSize)",
-    fontSizeMini: "var(--text-xs-fontSize)",
-    fontSizeTiny: "var(--text-xs-fontSize)",
-    fontSizeSmall: "var(--text-sm-fontSize)",
-    fontSizeMedium: "var(--text-base-fontSize)",
-    fontSizeLarge: "var(--text-lg-fontSize)",
-    fontSizeHuge: "var(--text-xl-fontSize)",
-    lineHeight: "1.5",
-    textColorBase: "var(--colors-dark-400)",
-    textColor1: "var(--colors-dark-200)",
-    textColor2: "var(--colors-dark-50)",
-    textColor3: "var(--colors-gray-500)",
-    textColorDisabled: "var(--colors-gray-400)",
-    bodyColor: theme_variables_default.light
-  },
-  Card: {
-    color: "var(--colors-light-400)",
-    colorEmbedded: "var(--colors-light-50)",
-    borderColor: "var(--colors-gray-200)"
-  }
-};
+function getThemeOverridesLight(options = {}) {
+  const { theme = {} } = options;
+  const mergedTheme = mergeDeep(themeVariables, theme);
+  const shared = getThemeOverridesShared(options);
+  const light = {
+    common: {
+      primaryColor: mergedTheme.primary,
+      primaryColorHover: mergedTheme.primaryHover,
+      primaryColorPressed: mergedTheme.primaryPressed,
+      primaryColorSuppl: mergedTheme.primary,
+      infoColor: mergedTheme.info,
+      infoColorHover: mergedTheme.infoHover,
+      infoColorPressed: mergedTheme.infoPressed,
+      infoColorSuppl: mergedTheme.info,
+      successColor: mergedTheme.success,
+      successColorHover: mergedTheme.successHover,
+      successColorPressed: mergedTheme.successPressed,
+      successColorSuppl: mergedTheme.success,
+      warningColor: mergedTheme.warning,
+      warningColorHover: mergedTheme.warningHover,
+      warningColorPressed: mergedTheme.warningPressed,
+      warningColorSuppl: mergedTheme.warning,
+      errorColor: mergedTheme.danger,
+      errorColorHover: mergedTheme.dangerHover,
+      errorColorPressed: mergedTheme.dangerPressed,
+      errorColorSuppl: mergedTheme.danger,
+      bodyColor: mergedTheme.light
+    }
+  };
+  return mergeDeep(shared, light);
+}
+var themeOverridesLight = getThemeOverridesLight();
 export {
-  theme_overrides_light_default as themeOverridesLight,
-  theme_overrides_dark_default as themeOverridesDark
+  themeOverridesLight,
+  themeOverridesDark,
+  getThemeOverridesLight,
+  getThemeOverridesDark
 };