@tenoxui/moxie 0.3.2 → 0.4.0-alpha.0

package/dist/index.d.ts

@@ -4,8 +4,7 @@ export declare class TenoxUI {
     private property;
     private values;
     private classes;
-    private aliases;
-    constructor({ property, values, classes, aliases }?: Config);
+    constructor({ property, values, classes }?: Config);
     toKebabCase(str: string): string;
     escapeCSSSelector(str: string): string;
     private getAllClassNames;
@@ -17,7 +16,6 @@ export declare class TenoxUI {
     private parseValuePattern;
     private getParentClass;
     processCustomClass(className: string | undefined, value?: string | undefined, unit?: string | undefined, prefix?: string | undefined, secValue?: string | undefined, secUnit?: string | undefined, isHyphen?: boolean): ProcessedStyle | null;
-    processAlias(className: string, prefix?: string): ProcessedStyle | null;
     process(classNames: string | string[]): ProcessedStyle[];
 }
 export default TenoxUI;

package/dist/index.es.js

@@ -1,372 +1,249 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
+var S = Object.defineProperty;
+var x = Object.getOwnPropertySymbols;
+var Z = Object.prototype.hasOwnProperty, j = Object.prototype.propertyIsEnumerable;
+var V = (P, s, t) => s in P ? S(P, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : P[s] = t, v = (P, s) => {
+  for (var t in s || (s = {}))
+    Z.call(s, t) && V(P, t, s[t]);
+  if (x)
+    for (var t of x(s))
+      j.call(s, t) && V(P, t, s[t]);
+  return P;
 };
-class TenoxUI {
-  constructor({ property = {}, values = {}, classes = {}, aliases = {} } = {}) {
-    this.property = __spreadValues({
-      moxie: ({ key }) => key
-    }, property);
-    this.values = values;
-    this.classes = classes;
-    this.aliases = aliases;
+class _ {
+  constructor({ property: s = {}, values: t = {}, classes: e = {} } = {}) {
+    this.property = v({
+      moxie: ({ key: n }) => n
+    }, s), this.values = t, this.classes = e;
   }
-  toKebabCase(str) {
-    if (/^(webkit|moz|ms|o)[A-Z]/.test(str)) {
-      const match = str.match(/^(webkit|moz|ms|o)/);
-      if (match) {
-        const prefix = match[0];
-        return `-${prefix}${str.slice(prefix.length).replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}`;
+  toKebabCase(s) {
+    if (/^(webkit|moz|ms|o)[A-Z]/.test(s)) {
+      const t = s.match(/^(webkit|moz|ms|o)/);
+      if (t) {
+        const e = t[0];
+        return `-${e}${s.slice(e.length).replace(/[A-Z]/g, (n) => `-${n.toLowerCase()}`)}`;
       }
     }
-    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+    return s.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
   }
-  escapeCSSSelector(str) {
-    return str.replace(/([ #{}.:;?%&,@+*~'"!^$[\]()=>|/])/g, "\\$1");
+  escapeCSSSelector(s) {
+    return s.replace(/([ #{}.:;?%&,@+*~'"!^$[\]()=>|/])/g, "\\$1");
   }
-  getAllClassNames(classRegistry) {
-    if (!classRegistry) return [];
-    const classNames = /* @__PURE__ */ new Set();
-    Object.entries(classRegistry).forEach(([property, classObj]) => {
-      if (classObj && typeof classObj === "object") {
-        Object.keys(classObj).forEach((className) => {
-          classNames.add(className);
-        });
-      }
-    });
-    return Array.from(classNames);
+  getAllClassNames(s) {
+    if (!s) return [];
+    const t = /* @__PURE__ */ new Set();
+    return Object.entries(s).forEach(([e, n]) => {
+      n && typeof n == "object" && Object.keys(n).forEach((r) => {
+        t.add(r);
+      });
+    }), Array.from(t);
   }
-  getTypePrefixes(safelist = []) {
-    const styleAttribute = this.property;
-    const classRegistry = this.classes;
-    const propertyTypes = Object.keys(styleAttribute);
-    if (!classRegistry) {
-      return [...propertyTypes, ...safelist].sort((a, b) => b.length - a.length).join("|");
-    }
-    const classConfigs = this.getAllClassNames(classRegistry);
-    const classPatterns = [...classConfigs];
-    return [...propertyTypes, ...classPatterns, ...safelist].sort((a, b) => b.length - a.length).join("|");
+  getTypePrefixes(s = []) {
+    const t = this.property, e = this.classes, n = Object.keys(t);
+    if (!e)
+      return [...n, ...s].sort((l, i) => i.length - l.length).join("|");
+    const a = [...this.getAllClassNames(e)];
+    return [...n, ...a, ...s].sort((l, i) => i.length - l.length).join("|");
   }
-  generateClassNameRegEx(safelist) {
-    const typePrefixes = this.getTypePrefixes(safelist);
-    const nestedBracketPattern = "\\[[^\\]]+\\]";
-    const nestedParenPattern = "\\([^()]*(?:\\([^()]*\\)[^()]*)*\\)";
-    const nestedBracePattern = "\\{[^{}]*(?:\\{[^{}]*\\}[^{}]*)*\\}";
-    const prefixPattern = "(?:([a-zA-Z0-9_-]+|[a-zA-Z0-9_-]+(?:-" + nestedBracketPattern + ")|" + // Direct bracket, parenthesis, or brace content
-    nestedBracketPattern + "|" + nestedParenPattern + "|" + nestedBracePattern + "):)?";
-    const typePattern = `(${typePrefixes}|\\[[^\\]]+\\])`;
-    const separator = "(?:-)?";
-    const valuePattern = "(-?(?:\\d+(?:\\.\\d+)?)|(?:[a-zA-Z0-9_]+(?:-[a-zA-Z0-9_]+)*(?:-[a-zA-Z0-9_]+)*)|(?:#[0-9a-fA-F]+)|" + // Hex colors
-    nestedBracketPattern + "|" + // Bracket content
-    nestedBracePattern + "|" + // Curly brace content
-    nestedParenPattern + "|(?:\\$[^\\s\\/]+))";
-    const unitPattern = "([a-zA-Z%]*)";
-    const secondaryPattern = "(?:\\/(-?(?:\\d+(?:\\.\\d+)?)|(?:[a-zA-Z0-9_]+(?:-[a-zA-Z0-9_]+)*(?:-[a-zA-Z0-9_]+)*)|(?:#[0-9a-fA-F]+)|" + nestedBracketPattern + "|" + nestedBracePattern + "|" + nestedParenPattern + "|(?:\\$[^\\s\\/]+))([a-zA-Z%]*))?";
+  generateClassNameRegEx(s) {
+    const t = this.getTypePrefixes(s), e = "\\[[^\\]]+\\]", n = "\\([^()]*(?:\\([^()]*\\)[^()]*)*\\)", r = "\\{[^{}]*(?:\\{[^{}]*\\}[^{}]*)*\\}", a = "(?:([a-zA-Z0-9_-]+|[a-zA-Z0-9_-]+(?:-(?:" + e + "|" + n + "|" + r + "))|" + // Direct bracket, parenthesis, or brace content
+    e + "|" + n + "|" + r + "):)?", l = `(${t}|\\[[^\\]]+\\])`, i = "(?:-)?", u = "(-?(?:\\d+(?:\\.\\d+)?)|(?:[a-zA-Z0-9_]+(?:-[a-zA-Z0-9_]+)*(?:-[a-zA-Z0-9_]+)*)|(?:#[0-9a-fA-F]+)|" + // Hex colors
+    e + "|" + // Bracket content
+    r + "|" + // Curly brace content
+    n + "|(?:\\$[^\\s\\/]+))", h = "([a-zA-Z%]*)", c = "(?:\\/(-?(?:\\d+(?:\\.\\d+)?)|(?:[a-zA-Z0-9_]+(?:-[a-zA-Z0-9_]+)*(?:-[a-zA-Z0-9_]+)*)|(?:#[0-9a-fA-F]+)|" + e + "|" + r + "|" + n + "|(?:\\$[^\\s\\/]+))([a-zA-Z%]*))?";
     return new RegExp(
-      prefixPattern + typePattern + separator + valuePattern + unitPattern + secondaryPattern
+      a + l + i + u + h + c
     );
   }
-  parse(className, safelist) {
-    if (Object.values(this.classes).some((classObj) => classObj == null ? void 0 : classObj[className])) {
-      return [void 0, className, "", "", void 0, void 0];
-    }
-    const classNameRegEx = this.generateClassNameRegEx(safelist);
-    const match = (className + "-dummy").match(classNameRegEx);
-    if (!match) return null;
-    const [, prefix, type, value, unit, secValue, secUnit] = match;
-    const finalValue = value === "dummy" ? "" : value.replace("-dummy", "");
-    return [prefix, type, finalValue, unit || "", secValue, secUnit];
+  parse(s, t) {
+    if (Object.values(this.classes).some((o) => o == null ? void 0 : o[s]))
+      return [void 0, s, "", "", void 0, void 0];
+    const e = this.generateClassNameRegEx(t), n = (s + "-dummy").match(e);
+    if (!n) return null;
+    const [, r, a, l, i, u, h] = n, c = l ? l === "dummy" ? "" : l.replace("-dummy", "") : "", f = u ? u === "dummy" ? "" : u.replace("-dummy", "") : "";
+    return [r, a, c, i || "", f, h];
   }
   // unique value parser
-  processValue(value, unit, group) {
-    if (!value) return "";
-    const replaceWithValueRegistry = (text) => {
-      return text.replace(/\{([^}]+)\}/g, (match, key) => {
-        const valueRegistry = this.values;
-        const val = valueRegistry !== null ? typeof valueRegistry[group] === "object" ? valueRegistry[group][key] : valueRegistry[key] : void 0;
-        return typeof val === "string" ? val : match;
-      });
-    };
-    if (typeof this.values === "object" && this.values !== null && (this.values[group] && typeof this.values[group] === "object" && this.values[group][value] || this.values[value])) {
-      if (typeof this.values[group] === "object" && this.values[group] !== null) {
-        return this.values[group][value];
-      }
-      return this.values[value];
-    } else if (value.startsWith("$")) {
-      return `var(--${value.slice(1)})`;
-    } else if (value.startsWith("[") && value.endsWith("]") || value.startsWith("(") && value.endsWith(")")) {
-      const cleanValue = value.slice(1, -1).replace(/_/g, " ");
-      if (cleanValue.includes("{")) {
-        return replaceWithValueRegistry(cleanValue);
-      }
-      return cleanValue.startsWith("--") ? `var(${cleanValue})` : cleanValue;
+  processValue(s, t, e) {
+    if (!s) return "";
+    const n = (r) => r.replace(/\{([^}]+)\}/g, (a, l) => {
+      const i = this.values, u = i !== null ? typeof i[e] == "object" ? i[e][l] : i[l] : void 0;
+      return typeof u == "string" ? u : a;
+    });
+    if (typeof this.values == "object" && this.values !== null && (this.values[e] && typeof this.values[e] == "object" && this.values[e][s] || this.values[s]))
+      return typeof this.values[e] == "object" && this.values[e] !== null ? this.values[e][s] : this.values[s];
+    if (s.startsWith("$"))
+      return `var(--${s.slice(1)})`;
+    if (s.startsWith("[") && s.endsWith("]") || s.startsWith("(") && s.endsWith(")")) {
+      const r = s.slice(1, -1).replace(/_/g, " ");
+      return r.includes("{") ? n(r) : r.startsWith("--") ? `var(${r})` : r;
     }
-    return value + (unit || "");
+    return s + (t || "");
   }
-  processShorthand(type = "", value = "", unit = "", prefix, secondValue = "", secondUnit = "", isHyphen = true) {
-    const properties = this.property[type];
-    const pattern = /^(?:\(|\[)([^:]+):(.+)(?:\)|\])$/;
-    let extractedFor = null;
-    let cleanValue = value || "";
-    const matchValue = cleanValue.match(pattern);
-    if (matchValue) {
-      extractedFor = matchValue[1].trim();
-      cleanValue = matchValue[2].trim();
-    }
-    let finalCleanValue;
-    if (value.includes(extractedFor + ":")) {
-      finalCleanValue = value.startsWith("(") ? `(${cleanValue})` : `[${cleanValue}]`;
-    } else finalCleanValue = value;
-    const finalValue = this.processValue(finalCleanValue, unit, type);
-    const finalSecValue = this.processValue(secondValue, secondUnit, type);
-    if (type.startsWith("[") && type.endsWith("]")) {
-      const items = type.slice(1, -1).split(",").map((item) => item.trim());
-      const cssRules = items.map((item) => {
-        const prop = this.property[item] || item;
-        const finalProperty = typeof prop === "string" && prop.startsWith("--") ? String(prop) : this.toKebabCase(String(prop));
-        return `${finalProperty}: ${finalValue}`;
-      }).join("; ");
+  processShorthand(s = "", t = "", e = "", n, r = "", a = "", l = !0) {
+    const i = this.property[s], u = /^(?:\(|\[)([^:]+):(.+)(?:\)|\])$/;
+    let h = null, c = t || "";
+    const f = c.match(u);
+    f && (h = f[1].trim(), c = f[2].trim());
+    let o;
+    t.includes(h + ":") ? o = t.startsWith("(") ? `(${c})` : `[${c}]` : o = t;
+    const p = this.processValue(o, e, s), y = this.processValue(r, a, s);
+    if (s.startsWith("[") && s.endsWith("]")) {
+      const C = s.slice(1, -1).split(",").map(($) => $.trim()).map(($) => `${$.startsWith("--") ? String($) : this.toKebabCase(String($))}: ${p}`).join("; ");
       return {
-        className: `${`[${type.slice(1, -1)}]${isHyphen ? "-" : ""}${value}${unit}`}`,
-        cssRules,
+        className: `${`[${s.slice(1, -1)}]${l ? "-" : ""}${t}${e}`}`,
+        cssRules: C,
         // return css rules directly
         value: null,
         // and set value to null to prevent value duplication
-        prefix
+        prefix: n
       };
     }
-    if (properties) {
-      if (typeof properties === "object" && "property" in properties && "value" in properties) {
-        const groupValue = properties.group && this.values[properties.group] ? this.values[properties.group][finalValue] : unit ? value : finalValue;
-        const property = typeof properties.property === "function" ? properties.property({
-          value: groupValue,
-          unit,
-          secondValue: secondUnit ? secondValue : finalSecValue,
-          secondUnit,
-          key: extractedFor
-        }) : properties.property;
-        const template = properties.value;
-        let processedValue;
-        if (typeof template === "function") {
-          processedValue = template({
-            value: groupValue,
-            unit,
-            secondValue: secondUnit ? secondValue : finalSecValue,
-            secondUnit,
-            key: extractedFor,
-            property
+    if (i) {
+      if (typeof i == "object" && "property" in i) {
+        const C = i.group && this.values[i.group][p] ? this.values[i.group][p] : e ? t : p, $ = typeof i.property == "function" ? i.property({
+          value: t.startsWith("[") ? p : C,
+          unit: t.startsWith("[") ? "" : e,
+          secondValue: t.startsWith("[") ? "" : a ? r : y,
+          secondUnit: t.startsWith("[") ? "" : a,
+          key: h
+        }) : i.property, g = i.value || "{0}";
+        let A;
+        if (typeof g == "function")
+          A = g({
+            value: C,
+            unit: e,
+            secondValue: a ? r : y,
+            secondUnit: a,
+            key: h
           });
-        } else if (template && typeof template === "string") {
-          const valuesGroup = properties.group || type;
-          const newValue = this.processValue(finalCleanValue, unit, valuesGroup);
-          processedValue = this.values[finalCleanValue] || this.values[valuesGroup][finalCleanValue] || finalCleanValue.includes("{") || template.includes("{") ? this.parseValuePattern(valuesGroup, template, newValue, "", finalSecValue, "") : finalValue;
-        } else processedValue = null;
-        const className = `${type}${value ? `${isHyphen ? isHyphen ? "-" : "" : ""}${value}${unit}` : ""}${secondValue ? `/${secondValue}${secondUnit}` : ""}`;
+        else if (typeof g == "string") {
+          const d = i.group || s, W = this.processValue(o, e, d);
+          this.values[d] && typeof this.values[d] == "object" && this.values[d][o] ? A = this.values[d][o] : g.includes("{") ? A = this.parseValuePattern(
+            d,
+            g,
+            W,
+            "",
+            y,
+            ""
+          ) : A = p;
+        } else A = null;
         return {
-          className,
-          cssRules: Array.isArray(property) ? property : typeof property === "string" && property.includes(":") ? property : this.toKebabCase(String(property)),
-          value: template === null ? null : value.startsWith("[") ? finalValue : processedValue,
-          prefix
+          className: `${s}${t ? `${l && l ? "-" : ""}${t}${e}` : ""}${r ? `/${r}${a}` : ""}`,
+          cssRules: Array.isArray($) ? $ : typeof $ == "string" && ($.includes(":") || $.includes("value:")) ? $.includes("value:") ? $.slice(6) : this.toKebabCase(String($)) : this.toKebabCase(String($)),
+          value: g === null || $.includes("value:") ? null : t.startsWith("[") ? p : A,
+          prefix: n
         };
       }
-      const finalRegProperty = typeof properties === "function" ? properties({
-        value: unit ? value : finalValue,
-        unit,
-        secondValue: secondUnit ? secondValue : finalSecValue,
-        secondUnit,
-        key: extractedFor
-      }) : properties;
+      const m = typeof i == "function" ? i({
+        value: t.startsWith("[") ? p : e ? t : p,
+        unit: t.startsWith("[") ? "" : e,
+        secondValue: t.startsWith("[") ? "" : a ? r : y,
+        secondUnit: t.startsWith("[") ? "" : a,
+        key: h
+      }) : i;
       return {
-        className: `${type}${value ? (isHyphen ? "-" : "") + value + unit : ""}`,
-        cssRules: Array.isArray(properties) ? finalRegProperty : typeof finalRegProperty === "string" && finalRegProperty.startsWith("value:") ? finalRegProperty.slice(6) : this.toKebabCase(String(finalRegProperty)),
-        value: typeof finalRegProperty === "string" && finalRegProperty.startsWith("value:") ? null : finalValue,
-        prefix
+        className: `${s}${t ? (l ? "-" : "") + t + e : ""}${r ? `/${r}${a}` : ""}`,
+        cssRules: Array.isArray(i) ? m : typeof m == "string" && m.startsWith("value:") ? m.slice(6) : this.toKebabCase(String(m)),
+        value: typeof m == "string" && m.startsWith("value:") ? null : p,
+        prefix: n
       };
     }
     return null;
   }
-  parseValuePattern(group, pattern, inputValue, inputUnit, inputSecValue, inputSecUnit) {
-    if (!pattern.includes("{0}") && !pattern.includes("{1") && !pattern.includes("||"))
-      return pattern;
-    const [value, defaultValue] = pattern.split("||").map((s) => s.trim());
-    const finalValue = this.processValue(inputValue, inputUnit, group);
-    const finalSecValue = this.processValue(inputSecValue, inputSecUnit, group);
-    if (pattern.includes("{0}") && pattern.includes("{1") || pattern.includes("{1")) {
-      let computedValue = value;
-      if (inputValue) {
-        computedValue = computedValue.replace("{0}", finalValue);
-      }
-      if (pattern.includes("{1")) {
-        const match = computedValue.match(/{1([^}]*)}/);
-        if (pattern.includes("{1}")) {
-          if (inputSecValue) {
-            computedValue = inputSecValue.startsWith("[") ? finalSecValue : computedValue.replace("{1}", finalSecValue);
-          } else {
-            computedValue = defaultValue;
-          }
-        } else if (match) {
-          const fullMatch = match[0];
-          const innerContent = match[1].trim();
-          let replacementValue = finalSecValue;
-          if (!replacementValue && innerContent.includes("|")) {
-            replacementValue = innerContent.split("|")[1].trim();
-          } else if (!replacementValue) {
-            replacementValue = "";
-          }
-          computedValue = inputValue.startsWith("[") ? finalValue : computedValue.replace(fullMatch, replacementValue);
+  parseValuePattern(s, t, e, n, r, a) {
+    if (!t.includes("{0}") && !t.includes("{1") && !t.includes("||"))
+      return t;
+    const [l, i] = t.split("||").map((c) => c.trim()), u = this.processValue(e, n, s), h = this.processValue(r, a, s);
+    if (t.includes("{0}") && t.includes("{1") || t.includes("{1")) {
+      let c = l;
+      if (e && (c = c.replace("{0}", u)), t.includes("{1")) {
+        const f = c.match(/{1([^}]*)}/);
+        if (t.includes("{1}"))
+          r ? c = r.startsWith("[") ? h : c.replace("{1}", h) : c = i;
+        else if (f) {
+          const o = f[0], p = f[1].trim();
+          let y = h;
+          !y && p.includes("|") ? y = p.split("|")[1].trim() : y || (y = ""), c = e.startsWith("[") ? u : c.replace(o, y);
         }
       }
-      return inputValue ? computedValue : defaultValue || value;
-    } else {
-      return inputValue ? inputValue.startsWith("[") ? finalValue : value.replace("{0}", finalValue) : defaultValue || value;
-    }
+      return e ? c : i || l;
+    } else
+      return e ? e.startsWith("[") ? u : l.replace("{0}", u) : i || l;
   }
-  getParentClass(className) {
+  getParentClass(s) {
     return Object.keys(this.classes).filter(
-      (cssProperty) => Object.prototype.hasOwnProperty.call(
-        this.classes[cssProperty],
-        className
+      (t) => Object.prototype.hasOwnProperty.call(
+        this.classes[t],
+        s
       )
     );
   }
-  processCustomClass(className, value = "", unit = "", prefix = "", secValue = "", secUnit = "", isHyphen = true) {
-    if (!className) return null;
-    const properties = this.getParentClass(className);
-    if (properties.length > 0) {
-      const rules = properties.map((prop) => {
-        const classObj = this.classes[prop];
-        if (!classObj) return "";
-        const processedValue = this.parseValuePattern(
-          className,
-          classObj[className] || "",
-          value,
-          unit,
-          secValue,
-          secUnit
+  processCustomClass(s, t = "", e = "", n = "", r = "", a = "", l = !0) {
+    if (!s) return null;
+    const i = this.getParentClass(s);
+    if (i.length > 0) {
+      const u = i.map((f) => {
+        const o = this.classes[f];
+        if (!o) return "";
+        const p = this.parseValuePattern(
+          s,
+          o[s] || "",
+          t,
+          e,
+          r,
+          a
         );
-        return `${this.toKebabCase(String(prop))}: ${processedValue}`;
-      }).filter(Boolean).join("; ");
-      const isValueType = className.slice(-(value + unit).length);
-      const finalClassName = `${className}${value ? `${isHyphen ? "-" : ""}${value}${unit}` : ""}${secValue ? `/${secValue}${secUnit}` : ""}`;
+        return `${this.toKebabCase(String(f))}: ${p}`;
+      }).filter(Boolean).join("; "), h = s.slice(-(t + e).length), c = `${s}${t ? `${l ? "-" : ""}${t}${e}` : ""}${r ? `/${r}${a}` : ""}`;
       return {
-        className: value === isValueType ? className : finalClassName,
-        cssRules: rules,
+        className: t === h ? s : c,
+        cssRules: u,
         value: null,
-        prefix
+        prefix: n
       };
     }
     return null;
   }
-  processAlias(className, prefix = "") {
-    const alias = this.aliases[className];
-    if (!alias) return null;
-    const aliasClasses = alias.split(" ");
-    const combinedRules = [];
-    aliasClasses.forEach((aliasClass) => {
-      const [rprefix, rtype] = aliasClass.split(":");
-      const getType = rtype || rprefix;
-      const getPrefix = rtype ? rprefix : void 0;
-      const parts = this.parse(aliasClass);
-      const parsed = parts ? parts : [getPrefix, getType, "", ""];
-      if (!parsed) return;
-      const [prefix2, type, value, unit, secValue, secUnit] = parsed;
-      const result = this.processShorthand(type, value, unit, void 0, secValue, secUnit);
-      const shouldClasses = this.processCustomClass(type, value, unit, prefix2, secValue, secUnit);
-      if (shouldClasses) {
-        const { cssRules } = shouldClasses;
-        combinedRules.push(cssRules);
-        return;
-      }
-      if (result) {
-        const value2 = result.value !== null ? `: ${result.value}` : "";
-        if (Array.isArray(result.cssRules)) {
-          result.cssRules.forEach((rule) => {
-            combinedRules.push(`${this.toKebabCase(rule)}${value2}`);
-          });
-        } else {
-          combinedRules.push(`${result.cssRules}${value2}`);
-        }
-      }
-    });
-    return {
-      className,
-      cssRules: combinedRules.join("; "),
-      value: null,
-      prefix
-    };
-  }
-  process(classNames) {
-    const classList = Array.isArray(classNames) ? classNames : classNames.split(/\s+/);
-    const results = [];
-    classList.forEach((className) => {
-      if (!className) return this;
-      const [rprefix, rtype] = className.split(":");
-      const getType = rtype || rprefix;
-      const getPrefix = rtype ? rprefix : void 0;
-      const aliasResult = this.processAlias(getType, getPrefix);
-      if (aliasResult) {
-        const { className: aliasClassName, cssRules } = aliasResult;
-        results.push({
-          className: aliasClassName,
-          cssRules,
-          value: null,
-          prefix: getPrefix
-        });
-        return;
-      }
-      const parts = this.parse(className);
-      const parsed = parts ? parts : [getPrefix, getType, "", ""];
-      if (!parsed) return this;
-      const [prefix, type, value, unit, secValue, secUnit] = parsed;
-      const isHyphen = !className.includes((type || "") + (value || ""));
-      const classFromClasses = this.getParentClass(`${type}${isHyphen ? "-" : ""}${value}`).length > 0 ? `${type}${isHyphen ? "-" : ""}${value}` : type;
-      const shouldClasses = this.processCustomClass(
-        classFromClasses,
-        value,
-        unit,
-        prefix,
-        secValue,
-        secUnit,
-        isHyphen
+  process(s) {
+    const t = Array.isArray(s) ? s : s.split(/\s+/), e = [];
+    return t.forEach((n) => {
+      if (!n) return this;
+      const [r, a] = n.split(":"), l = a || r, i = a ? r : void 0, u = this.parse(n), h = u || [i, l, "", ""];
+      if (!h) return this;
+      const [c, f, o, p, y, m] = h, C = !n.includes((f || "") + (o || "")), $ = this.getParentClass(`${f}${C ? "-" : ""}${o}`).length > 0 ? `${f}${C ? "-" : ""}${o}` : f, g = this.processCustomClass(
+        $,
+        o,
+        p,
+        c,
+        y,
+        m,
+        C
       );
-      if (shouldClasses) {
-        const { className: className2, cssRules, prefix: prefix2 } = shouldClasses;
-        results.push({
-          className: className2,
-          cssRules,
+      if (g) {
+        const { className: b, cssRules: d, prefix: W } = g;
+        e.push({
+          className: b,
+          cssRules: d,
           value: null,
-          prefix: prefix2
+          prefix: W
         });
         return;
       }
-      const result = this.processShorthand(type, value, unit, prefix, secValue, secUnit, isHyphen);
-      if (result) {
-        const { className: className2, cssRules, value: ruleValue, prefix: rulePrefix } = result;
-        results.push({
-          className: className2,
-          cssRules,
-          value: ruleValue,
-          prefix: rulePrefix
+      const A = this.processShorthand(f, o, p, c, y, m, C);
+      if (A) {
+        const { className: b, cssRules: d, value: W, prefix: R } = A;
+        e.push({
+          className: b,
+          cssRules: d,
+          value: W,
+          prefix: R
         });
       }
-    });
-    return results;
+    }), e;
   }
 }
 export {
-  TenoxUI,
-  TenoxUI as default
+  _ as TenoxUI,
+  _ as default
 };
 //# sourceMappingURL=index.es.js.map