@gjfleo/theme 0.2.1 → 0.2.4

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(e2, dataSetPropName) {
-    let { target } = e2;
+  function happensIn(e, dataSetPropName) {
+    let { target } = e;
     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 (e2) {
-      throw e2;
+    } catch (e) {
+      throw e;
     }
   }
   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 (e2) {
-      throw e2;
+    } catch (e) {
+      throw e;
     }
   }
   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 (e2) {
-      throw e2;
+    } catch (e) {
+      throw e;
     }
   }
   function normalizeAlpha(alphaValue) {
@@ -942,1217 +942,27 @@ var DEFAULT_LAYERS = {
   [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 (Array.isArray(p))
     if (mergeArray && Array.isArray(p))
       return [...o, ...p];
     else
       return [...p];
-  }
   const output = { ...o };
-  if (isObject(o) && isObject(p)) {
+  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 = {}) {
@@ -2256,7 +1066,7 @@ function getThemeOverridesLight(options = {}) {
       errorColorHover: mergedTheme.dangerHover,
       errorColorPressed: mergedTheme.dangerPressed,
       errorColorSuppl: mergedTheme.danger,
-      bodyColor: themeVariables.light
+      bodyColor: mergedTheme.light
     }
   };
   return mergeDeep(shared, light);

package/dist/unocss/index.d.ts

@@ -2,6 +2,8 @@
 
 import { PresetWind4Theme } from 'unocss';
 
+export declare function extendPresetWind4ThemeColor(theme: PresetWind4Theme): void;
+export declare function extendPresetWind4ThemeText(theme: PresetWind4Theme): void;
 export declare function extendPresetWind4Theme(theme: PresetWind4Theme): void;
 
 export {};

package/dist/unocss/index.js

@@ -963,7 +963,7 @@ var themeVariables = {
 };
 
 // src/unocss/index.ts
-function extendPresetWind4Theme(theme) {
+function extendPresetWind4ThemeColor(theme) {
   theme.colors = theme.colors ?? {};
   theme.colors.primary = {
     DEFAULT: themeVariables.primary,
@@ -1009,12 +1009,20 @@ function extendPresetWind4Theme(theme) {
     900: "oklch(90.72% 0.026 140)",
     950: "oklch(89.23% 0.026 140)"
   };
+}
+function extendPresetWind4ThemeText(theme) {
   theme.text = theme.text ?? {};
   theme.text.xs = { fontSize: "0.75rem", lineHeight: "1rem" };
   theme.text.sm = { fontSize: "0.875rem", lineHeight: "1.25rem" };
   theme.text.base = { fontSize: "0.875rem", lineHeight: "1.25rem" };
   theme.text.lg = { fontSize: "1rem", lineHeight: "1.5rem" };
 }
+function extendPresetWind4Theme(theme) {
+  extendPresetWind4ThemeColor(theme);
+  extendPresetWind4ThemeText(theme);
+}
 export {
+  extendPresetWind4ThemeText,
+  extendPresetWind4ThemeColor,
   extendPresetWind4Theme
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gjfleo/theme",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "description": "GjfLeo's themes.",
   "author": "gjfLeo <gjfLeo@yeah.net>",
   "exports": {
@@ -29,15 +29,16 @@
     "release": "bumpp && bun publish"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.14.1",
-    "@gjfleo/eslint-config": "^1.1.0",
+    "@antfu/eslint-config": "^7.7.2",
+    "@gjfleo/eslint-config": "^1.2.5",
     "@types/bun": "latest",
-    "bumpp": "^10.2.0",
-    "bun-plugin-dts": "^0.3.0",
-    "eslint": "^9.29.0",
-    "naive-ui": "^2.42.0",
-    "typescript": "^5.8.3",
-    "unocss": "^66.2.1"
+    "bumpp": "^10.4.1",
+    "bun-plugin-dts": "^0.4.0",
+    "eslint": "^9.39.4",
+    "naive-ui": "^2.44.1",
+    "seemly": "^0.3.10",
+    "typescript": "^5.9.3",
+    "unocss": "^66.6.6"
   },
   "publishConfig": {
     "access": "public",