@pequity/squirrel 11.0.0 → 11.0.2

package/dist/es/chunks/index.js

@@ -1,233 +1,388 @@
-var y = /\s+/g, a = (t) => typeof t != "string" || !t ? t : t.replace(y, " ").trim(), u = (...t) => {
-  let r = [], n = (e) => {
-    if (!e && e !== 0 && e !== 0n) return;
-    if (Array.isArray(e)) {
-      for (let s = 0, o = e.length; s < o; s++) n(e[s]);
+var SPACE_REGEX = /\s+/g;
+var removeExtraSpaces = (str) => {
+  if (typeof str !== "string" || !str) return str;
+  return str.replace(SPACE_REGEX, " ").trim();
+};
+var cx = (...classnames) => {
+  const classList = [];
+  const buildClassString = (input) => {
+    if (!input && input !== 0 && input !== 0n) return;
+    if (Array.isArray(input)) {
+      for (let i = 0, len = input.length; i < len; i++) buildClassString(input[i]);
       return;
     }
-    let f2 = typeof e;
-    if (f2 === "string" || f2 === "number" || f2 === "bigint") {
-      if (f2 === "number" && e !== e) return;
-      r.push(String(e));
-    } else if (f2 === "object") {
-      let s = Object.keys(e);
-      for (let o = 0, i2 = s.length; o < i2; o++) {
-        let l = s[o];
-        e[l] && r.push(l);
+    const type = typeof input;
+    if (type === "string" || type === "number" || type === "bigint") {
+      if (type === "number" && input !== input) return;
+      classList.push(String(input));
+    } else if (type === "object") {
+      const keys = Object.keys(input);
+      for (let i = 0, len = keys.length; i < len; i++) {
+        const key = keys[i];
+        if (input[key]) classList.push(key);
       }
     }
   };
-  for (let e = 0, f2 = t.length; e < f2; e++) {
-    let s = t[e];
-    s != null && n(s);
+  for (let i = 0, len = classnames.length; i < len; i++) {
+    const c = classnames[i];
+    if (c !== null && c !== void 0) buildClassString(c);
   }
-  return r.length > 0 ? a(r.join(" ")) : void 0;
-}, h = (t) => t === false ? "false" : t === true ? "true" : t === 0 ? "0" : t, x = (t) => {
-  if (!t || typeof t != "object") return true;
-  for (let r in t) return false;
+  return classList.length > 0 ? removeExtraSpaces(classList.join(" ")) : void 0;
+};
+var falsyToString = (value) => value === false ? "false" : value === true ? "true" : value === 0 ? "0" : value;
+var isEmptyObject = (obj) => {
+  if (!obj || typeof obj !== "object") return true;
+  for (const _ in obj) return false;
   return true;
-}, k = (t, r) => {
-  if (t === r) return true;
-  if (!t || !r) return false;
-  let n = Object.keys(t), e = Object.keys(r);
-  if (n.length !== e.length) return false;
-  for (let f2 = 0; f2 < n.length; f2++) {
-    let s = n[f2];
-    if (!e.includes(s) || t[s] !== r[s]) return false;
+};
+var isEqual = (obj1, obj2) => {
+  if (obj1 === obj2) return true;
+  if (!obj1 || !obj2) return false;
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (let i = 0; i < keys1.length; i++) {
+    const key = keys1[i];
+    if (!keys2.includes(key)) return false;
+    if (obj1[key] !== obj2[key]) return false;
   }
   return true;
-}, d = (t, r) => {
-  for (let n in r) if (Object.prototype.hasOwnProperty.call(r, n)) {
-    let e = r[n];
-    n in t ? t[n] = u(t[n], e) : t[n] = e;
+};
+var joinObjects = (obj1, obj2) => {
+  for (const key in obj2) {
+    if (Object.prototype.hasOwnProperty.call(obj2, key)) {
+      const val2 = obj2[key];
+      if (key in obj1) {
+        obj1[key] = cx(obj1[key], val2);
+      } else {
+        obj1[key] = val2;
+      }
+    }
   }
-  return t;
-}, c = (t, r) => {
-  for (let n = 0; n < t.length; n++) {
-    let e = t[n];
-    Array.isArray(e) ? c(e, r) : e && r.push(e);
+  return obj1;
+};
+var flat = (arr, target) => {
+  for (let i = 0; i < arr.length; i++) {
+    const el = arr[i];
+    if (Array.isArray(el)) flat(el, target);
+    else if (el) target.push(el);
+  }
+};
+var flatMergeArrays = (...arrays) => {
+  const result = [];
+  flat(arrays, result);
+  const filtered = [];
+  for (let i = 0; i < result.length; i++) {
+    if (result[i]) filtered.push(result[i]);
   }
+  return filtered;
 };
-var g = (...t) => {
-  let r = [];
-  c(t, r);
-  let n = [];
-  for (let e = 0; e < r.length; e++) r[e] && n.push(r[e]);
-  return n;
-}, p = (t, r) => {
-  let n = {};
-  for (let e in t) {
-    let f2 = t[e];
-    if (e in r) {
-      let s = r[e];
-      Array.isArray(f2) || Array.isArray(s) ? n[e] = g(s, f2) : typeof f2 == "object" && typeof s == "object" && f2 && s ? n[e] = p(f2, s) : n[e] = s + " " + f2;
-    } else n[e] = f2;
+var mergeObjects = (obj1, obj2) => {
+  const result = {};
+  for (const key in obj1) {
+    const val1 = obj1[key];
+    if (key in obj2) {
+      const val2 = obj2[key];
+      if (Array.isArray(val1) || Array.isArray(val2)) {
+        result[key] = flatMergeArrays(val2, val1);
+      } else if (typeof val1 === "object" && typeof val2 === "object" && val1 && val2) {
+        result[key] = mergeObjects(val1, val2);
+      } else {
+        result[key] = val2 + " " + val1;
+      }
+    } else {
+      result[key] = val1;
+    }
+  }
+  for (const key in obj2) {
+    if (!(key in obj1)) {
+      result[key] = obj2[key];
+    }
   }
-  for (let e in r) e in t || (n[e] = r[e]);
-  return n;
+  return result;
 };
-var Q = { twMerge: true, twMergeConfig: {}, responsiveVariants: false };
-function ne() {
-  let b = null, w = {}, A = false;
-  return { get cachedTwMerge() {
-    return b;
-  }, set cachedTwMerge(u2) {
-    b = u2;
-  }, get cachedTwMergeConfig() {
-    return w;
-  }, set cachedTwMergeConfig(u2) {
-    w = u2;
-  }, get didTwMergeConfigChange() {
-    return A;
-  }, set didTwMergeConfigChange(u2) {
-    A = u2;
-  }, reset() {
-    b = null, w = {}, A = false;
-  } };
+var defaultConfig = {
+  twMerge: true,
+  twMergeConfig: {}
+};
+function createState() {
+  let cachedTwMerge = null;
+  let cachedTwMergeConfig = {};
+  let didTwMergeConfigChange = false;
+  return {
+    get cachedTwMerge() {
+      return cachedTwMerge;
+    },
+    set cachedTwMerge(value) {
+      cachedTwMerge = value;
+    },
+    get cachedTwMergeConfig() {
+      return cachedTwMergeConfig;
+    },
+    set cachedTwMergeConfig(value) {
+      cachedTwMergeConfig = value;
+    },
+    get didTwMergeConfigChange() {
+      return didTwMergeConfigChange;
+    },
+    set didTwMergeConfigChange(value) {
+      didTwMergeConfigChange = value;
+    },
+    reset() {
+      cachedTwMerge = null;
+      cachedTwMergeConfig = {};
+      didTwMergeConfigChange = false;
+    }
+  };
 }
-var S = ne();
-var le = (b$1) => {
-  let w = (u$1, $) => {
-    let { extend: c$1 = null, slots: M = {}, variants: q = {}, compoundVariants: L = [], compoundSlots: v = [], defaultVariants: U = {} } = u$1, d$1 = { ...Q, ...$ }, x$1 = c$1?.base ? u(c$1.base, u$1?.base) : u$1?.base, p$1 = c$1?.variants && !x(c$1.variants) ? p(q, c$1.variants) : q, E = c$1?.defaultVariants && !x(c$1.defaultVariants) ? { ...c$1.defaultVariants, ...U } : U;
-    !x(d$1.twMergeConfig) && !k(d$1.twMergeConfig, S.cachedTwMergeConfig) && (S.didTwMergeConfigChange = true, S.cachedTwMergeConfig = d$1.twMergeConfig);
-    let N = x(c$1?.slots), O = x(M) ? {} : { base: u(u$1?.base, N && c$1?.base), ...M }, j$1 = N ? O : d({ ...c$1?.slots }, x(O) ? { base: u$1?.base } : O), T2 = x(c$1?.compoundVariants) ? L : g(c$1?.compoundVariants, L), y2 = (h$1) => {
-      if (x(p$1) && x(M) && N) return b$1(x$1, h$1?.class, h$1?.className)(d$1);
-      if (T2 && !Array.isArray(T2)) throw new TypeError(`The "compoundVariants" prop must be an array. Received: ${typeof T2}`);
-      if (v && !Array.isArray(v)) throw new TypeError(`The "compoundSlots" prop must be an array. Received: ${typeof v}`);
-      let Y = (t, e, n = [], a$1) => {
-        let r = n;
-        if (typeof e == "string") {
-          let i2 = a(e).split(" ");
-          for (let l = 0; l < i2.length; l++) r.push(`${t}:${i2[l]}`);
-        } else if (Array.isArray(e)) for (let s = 0; s < e.length; s++) r.push(`${t}:${e[s]}`);
-        else if (typeof e == "object" && typeof a$1 == "string" && a$1 in e) {
-          let s = e[a$1];
-          if (s && typeof s == "string") {
-            let l = a(s).split(" "), f2 = [];
-            for (let o = 0; o < l.length; o++) f2.push(`${t}:${l[o]}`);
-            r[a$1] = r[a$1] ? r[a$1].concat(f2) : f2;
-          } else if (Array.isArray(s) && s.length > 0) {
-            let i2 = [];
-            for (let l = 0; l < s.length; l++) i2.push(`${t}:${s[l]}`);
-            r[a$1] = i2;
-          }
+var state = createState();
+var getTailwindVariants = (cn2) => {
+  const tv2 = (options, configProp) => {
+    const {
+      extend = null,
+      slots: slotProps = {},
+      variants: variantsProps = {},
+      compoundVariants: compoundVariantsProps = [],
+      compoundSlots = [],
+      defaultVariants: defaultVariantsProps = {}
+    } = options;
+    const config = { ...defaultConfig, ...configProp };
+    const base = extend?.base ? cx(extend.base, options?.base) : options?.base;
+    const variants = extend?.variants && !isEmptyObject(extend.variants) ? mergeObjects(variantsProps, extend.variants) : variantsProps;
+    const defaultVariants = extend?.defaultVariants && !isEmptyObject(extend.defaultVariants) ? { ...extend.defaultVariants, ...defaultVariantsProps } : defaultVariantsProps;
+    if (!isEmptyObject(config.twMergeConfig) && !isEqual(config.twMergeConfig, state.cachedTwMergeConfig)) {
+      state.didTwMergeConfigChange = true;
+      state.cachedTwMergeConfig = config.twMergeConfig;
+    }
+    const isExtendedSlotsEmpty = isEmptyObject(extend?.slots);
+    const componentSlots = !isEmptyObject(slotProps) ? {
+      // add "base" to the slots object
+      base: cx(options?.base, isExtendedSlotsEmpty && extend?.base),
+      ...slotProps
+    } : {};
+    const slots = isExtendedSlotsEmpty ? componentSlots : joinObjects(
+      { ...extend?.slots },
+      isEmptyObject(componentSlots) ? { base: options?.base } : componentSlots
+    );
+    const compoundVariants = isEmptyObject(extend?.compoundVariants) ? compoundVariantsProps : flatMergeArrays(extend?.compoundVariants, compoundVariantsProps);
+    const component = (props) => {
+      if (isEmptyObject(variants) && isEmptyObject(slotProps) && isExtendedSlotsEmpty) {
+        return cn2(base, props?.class, props?.className)(config);
+      }
+      if (compoundVariants && !Array.isArray(compoundVariants)) {
+        throw new TypeError(
+          `The "compoundVariants" prop must be an array. Received: ${typeof compoundVariants}`
+        );
+      }
+      if (compoundSlots && !Array.isArray(compoundSlots)) {
+        throw new TypeError(
+          `The "compoundSlots" prop must be an array. Received: ${typeof compoundSlots}`
+        );
+      }
+      const getVariantValue = (variant, vrs = variants, _slotKey = null, slotProps2 = null) => {
+        const variantObj = vrs[variant];
+        if (!variantObj || isEmptyObject(variantObj)) {
+          return null;
         }
-        return r;
-      }, W = (t, e = p$1, n = null, a2 = null) => {
-        let r = e[t];
-        if (!r || x(r)) return null;
-        let s = a2?.[t] ?? h$1?.[t];
-        if (s === null) return null;
-        let i2 = h(s), l = Array.isArray(d$1.responsiveVariants) && d$1.responsiveVariants.length > 0 || d$1.responsiveVariants === true, f2 = E?.[t], o = [];
-        if (typeof i2 == "object" && l) for (let [C2, H] of Object.entries(i2)) {
-          let te = r[H];
-          if (C2 === "initial") {
-            f2 = H;
-            continue;
-          }
-          Array.isArray(d$1.responsiveVariants) && !d$1.responsiveVariants.includes(C2) || (o = Y(C2, te, o, n));
+        const variantProp = slotProps2?.[variant] ?? props?.[variant];
+        if (variantProp === null) return null;
+        const variantKey = falsyToString(variantProp);
+        if (typeof variantKey === "object") {
+          return null;
         }
-        let V = i2 != null && typeof i2 != "object" ? i2 : h(f2), m = r[V || "false"];
-        return typeof o == "object" && typeof n == "string" && o[n] ? d(o, m) : o.length > 0 ? (o.push(m), n === "base" ? o.join(" ") : o) : m;
-      }, Z = () => {
-        if (!p$1) return null;
-        let t = Object.keys(p$1), e = [];
-        for (let n = 0; n < t.length; n++) {
-          let a2 = W(t[n], p$1);
-          a2 && e.push(a2);
+        const defaultVariantProp = defaultVariants?.[variant];
+        const key = variantKey != null ? variantKey : falsyToString(defaultVariantProp);
+        const value = variantObj[key || "false"];
+        return value;
+      };
+      const getVariantClassNames = () => {
+        if (!variants) return null;
+        const keys = Object.keys(variants);
+        const result = [];
+        for (let i = 0; i < keys.length; i++) {
+          const value = getVariantValue(keys[i], variants);
+          if (value) result.push(value);
         }
-        return e;
-      }, _ = (t, e) => {
-        if (!p$1 || typeof p$1 != "object") return null;
-        let n = [];
-        for (let a2 in p$1) {
-          let r = W(a2, p$1, t, e), s = t === "base" && typeof r == "string" ? r : r && r[t];
-          s && n.push(s);
+        return result;
+      };
+      const getVariantClassNamesBySlotKey = (slotKey, slotProps2) => {
+        if (!variants || typeof variants !== "object") return null;
+        const result = [];
+        for (const variant in variants) {
+          const variantValue = getVariantValue(variant, variants, slotKey, slotProps2);
+          const value = slotKey === "base" && typeof variantValue === "string" ? variantValue : variantValue && variantValue[slotKey];
+          if (value) result.push(value);
         }
-        return n;
-      }, z = {};
-      for (let t in h$1) {
-        let e = h$1[t];
-        e !== void 0 && (z[t] = e);
+        return result;
+      };
+      const propsWithoutUndefined = {};
+      for (const prop in props) {
+        const value = props[prop];
+        if (value !== void 0) propsWithoutUndefined[prop] = value;
       }
-      let D = (t, e) => {
-        let n = typeof h$1?.[t] == "object" ? { [t]: h$1[t]?.initial } : {};
-        return { ...E, ...z, ...n, ...e };
-      }, G = (t = [], e) => {
-        let n = [], a2 = t.length;
-        for (let r = 0; r < a2; r++) {
-          let { class: s, className: i2, ...l } = t[r], f2 = true, o = D(null, e);
-          for (let V in l) {
-            let m = l[V], C2 = o[V];
-            if (Array.isArray(m)) {
-              if (!m.includes(C2)) {
-                f2 = false;
+      const getCompleteProps = (key, slotProps2) => {
+        const initialProp = typeof props?.[key] === "object" ? {
+          [key]: props[key]?.initial
+        } : {};
+        return {
+          ...defaultVariants,
+          ...propsWithoutUndefined,
+          ...initialProp,
+          ...slotProps2
+        };
+      };
+      const getCompoundVariantsValue = (cv = [], slotProps2) => {
+        const result = [];
+        const cvLength = cv.length;
+        for (let i = 0; i < cvLength; i++) {
+          const { class: tvClass, className: tvClassName, ...compoundVariantOptions } = cv[i];
+          let isValid = true;
+          const completeProps = getCompleteProps(null, slotProps2);
+          for (const key in compoundVariantOptions) {
+            const value = compoundVariantOptions[key];
+            const completePropsValue = completeProps[key];
+            if (Array.isArray(value)) {
+              if (!value.includes(completePropsValue)) {
+                isValid = false;
                 break;
               }
             } else {
-              if ((m == null || m === false) && (C2 == null || C2 === false)) continue;
-              if (C2 !== m) {
-                f2 = false;
+              if ((value == null || value === false) && (completePropsValue == null || completePropsValue === false))
+                continue;
+              if (completePropsValue !== value) {
+                isValid = false;
                 break;
               }
             }
           }
-          f2 && (s && n.push(s), i2 && n.push(i2));
+          if (isValid) {
+            if (tvClass) result.push(tvClass);
+            if (tvClassName) result.push(tvClassName);
+          }
         }
-        return n;
-      }, K = (t) => {
-        let e = G(T2, t);
-        if (!Array.isArray(e)) return e;
-        let n = {}, a2 = b$1;
-        for (let r = 0; r < e.length; r++) {
-          let s = e[r];
-          if (typeof s == "string") n.base = a2(n.base, s)(d$1);
-          else if (typeof s == "object") for (let i2 in s) n[i2] = a2(n[i2], s[i2])(d$1);
+        return result;
+      };
+      const getCompoundVariantClassNamesBySlot = (slotProps2) => {
+        const compoundClassNames = getCompoundVariantsValue(compoundVariants, slotProps2);
+        if (!Array.isArray(compoundClassNames)) return compoundClassNames;
+        const result = {};
+        const cnFn = cn2;
+        for (let i = 0; i < compoundClassNames.length; i++) {
+          const className = compoundClassNames[i];
+          if (typeof className === "string") {
+            result.base = cnFn(result.base, className)(config);
+          } else if (typeof className === "object") {
+            for (const slot in className) {
+              result[slot] = cnFn(result[slot], className[slot])(config);
+            }
+          }
         }
-        return n;
-      }, ee = (t) => {
-        if (v.length < 1) return null;
-        let e = {}, n = D(null, t);
-        for (let a2 = 0; a2 < v.length; a2++) {
-          let { slots: r = [], class: s, className: i2, ...l } = v[a2];
-          if (!x(l)) {
-            let f2 = true;
-            for (let o in l) {
-              let V = n[o], m = l[o];
-              if (V === void 0 || (Array.isArray(m) ? !m.includes(V) : m !== V)) {
-                f2 = false;
+        return result;
+      };
+      const getCompoundSlotClassNameBySlot = (slotProps2) => {
+        if (compoundSlots.length < 1) return null;
+        const result = {};
+        const completeProps = getCompleteProps(null, slotProps2);
+        for (let i = 0; i < compoundSlots.length; i++) {
+          const {
+            slots: slots2 = [],
+            class: slotClass,
+            className: slotClassName,
+            ...slotVariants
+          } = compoundSlots[i];
+          if (!isEmptyObject(slotVariants)) {
+            let isValid = true;
+            for (const key in slotVariants) {
+              const completePropsValue = completeProps[key];
+              const slotVariantValue = slotVariants[key];
+              if (completePropsValue === void 0 || (Array.isArray(slotVariantValue) ? !slotVariantValue.includes(completePropsValue) : slotVariantValue !== completePropsValue)) {
+                isValid = false;
                 break;
               }
             }
-            if (!f2) continue;
+            if (!isValid) continue;
           }
-          for (let f2 = 0; f2 < r.length; f2++) {
-            let o = r[f2];
-            e[o] || (e[o] = []), e[o].push([s, i2]);
+          for (let j = 0; j < slots2.length; j++) {
+            const slotName = slots2[j];
+            if (!result[slotName]) result[slotName] = [];
+            result[slotName].push([slotClass, slotClassName]);
           }
         }
-        return e;
+        return result;
       };
-      if (!x(M) || !N) {
-        let t = {};
-        if (typeof j$1 == "object" && !x(j$1)) {
-          let e = b$1;
-          for (let n in j$1) t[n] = (a2) => {
-            let r = K(a2), s = ee(a2);
-            return e(j$1[n], _(n, a2), r ? r[n] : void 0, s ? s[n] : void 0, a2?.class, a2?.className)(d$1);
-          };
+      if (!isEmptyObject(slotProps) || !isExtendedSlotsEmpty) {
+        const slotsFns = {};
+        if (typeof slots === "object" && !isEmptyObject(slots)) {
+          const cnFn = cn2;
+          for (const slotKey in slots) {
+            slotsFns[slotKey] = (slotProps2) => {
+              const compoundVariantClasses = getCompoundVariantClassNamesBySlot(slotProps2);
+              const compoundSlotClasses = getCompoundSlotClassNameBySlot(slotProps2);
+              return cnFn(
+                slots[slotKey],
+                getVariantClassNamesBySlotKey(slotKey, slotProps2),
+                compoundVariantClasses ? compoundVariantClasses[slotKey] : void 0,
+                compoundSlotClasses ? compoundSlotClasses[slotKey] : void 0,
+                slotProps2?.class,
+                slotProps2?.className
+              )(config);
+            };
+          }
         }
-        return t;
+        return slotsFns;
       }
-      return b$1(x$1, Z(), G(T2), h$1?.class, h$1?.className)(d$1);
-    }, X = () => {
-      if (!(!p$1 || typeof p$1 != "object")) return Object.keys(p$1);
+      return cn2(
+        base,
+        getVariantClassNames(),
+        getCompoundVariantsValue(compoundVariants),
+        props?.class,
+        props?.className
+      )(config);
     };
-    return y2.variantKeys = X(), y2.extend = c$1, y2.base = x$1, y2.slots = j$1, y2.variants = p$1, y2.defaultVariants = E, y2.compoundSlots = v, y2.compoundVariants = T2, y2;
+    const getVariantKeys = () => {
+      if (!variants || typeof variants !== "object") return;
+      return Object.keys(variants);
+    };
+    component.variantKeys = getVariantKeys();
+    component.extend = extend;
+    component.base = base;
+    component.slots = slots;
+    component.variants = variants;
+    component.defaultVariants = defaultVariants;
+    component.compoundSlots = compoundSlots;
+    component.compoundVariants = compoundVariants;
+    return component;
+  };
+  const createTV2 = (configProp) => {
+    return (options, config) => tv2(options, config ? mergeObjects(configProp, config) : configProp);
   };
-  return { tv: w, createTV: (u2) => ($, c2) => w($, c2 ? p(u2, c2) : u2) };
+  return {
+    tv: tv2,
+    createTV: createTV2
+  };
+};
+const concatArrays = (array1, array2) => {
+  const combinedArray = new Array(array1.length + array2.length);
+  for (let i = 0; i < array1.length; i++) {
+    combinedArray[i] = array1[i];
+  }
+  for (let i = 0; i < array2.length; i++) {
+    combinedArray[array1.length + i] = array2[i];
+  }
+  return combinedArray;
 };
+const createClassValidatorObject = (classGroupId, validator) => ({
+  classGroupId,
+  validator
+});
+const createClassPartObject = (nextPart = /* @__PURE__ */ new Map(), validators = null, classGroupId) => ({
+  nextPart,
+  validators,
+  classGroupId
+});
 const CLASS_PART_SEPARATOR = "-";
+const EMPTY_CONFLICTS = [];
+const ARBITRARY_PROPERTY_PREFIX = "arbitrary..";
 const createClassGroupUtils = (config) => {
   const classMap = createClassMap(config);
   const {
@@ -235,103 +390,134 @@ const createClassGroupUtils = (config) => {
     conflictingClassGroupModifiers
   } = config;
   const getClassGroupId = (className) => {
-    const classParts = className.split(CLASS_PART_SEPARATOR);
-    if (classParts[0] === "" && classParts.length !== 1) {
-      classParts.shift();
+    if (className.startsWith("[") && className.endsWith("]")) {
+      return getGroupIdForArbitraryProperty(className);
     }
-    return getGroupRecursive(classParts, classMap) || getGroupIdForArbitraryProperty(className);
+    const classParts = className.split(CLASS_PART_SEPARATOR);
+    const startIndex = classParts[0] === "" && classParts.length > 1 ? 1 : 0;
+    return getGroupRecursive(classParts, startIndex, classMap);
   };
   const getConflictingClassGroupIds = (classGroupId, hasPostfixModifier) => {
-    const conflicts = conflictingClassGroups[classGroupId] || [];
-    if (hasPostfixModifier && conflictingClassGroupModifiers[classGroupId]) {
-      return [...conflicts, ...conflictingClassGroupModifiers[classGroupId]];
+    if (hasPostfixModifier) {
+      const modifierConflicts = conflictingClassGroupModifiers[classGroupId];
+      const baseConflicts = conflictingClassGroups[classGroupId];
+      if (modifierConflicts) {
+        if (baseConflicts) {
+          return concatArrays(baseConflicts, modifierConflicts);
+        }
+        return modifierConflicts;
+      }
+      return baseConflicts || EMPTY_CONFLICTS;
     }
-    return conflicts;
+    return conflictingClassGroups[classGroupId] || EMPTY_CONFLICTS;
   };
   return {
     getClassGroupId,
     getConflictingClassGroupIds
   };
 };
-const getGroupRecursive = (classParts, classPartObject) => {
-  if (classParts.length === 0) {
+const getGroupRecursive = (classParts, startIndex, classPartObject) => {
+  const classPathsLength = classParts.length - startIndex;
+  if (classPathsLength === 0) {
     return classPartObject.classGroupId;
   }
-  const currentClassPart = classParts[0];
+  const currentClassPart = classParts[startIndex];
   const nextClassPartObject = classPartObject.nextPart.get(currentClassPart);
-  const classGroupFromNextClassPart = nextClassPartObject ? getGroupRecursive(classParts.slice(1), nextClassPartObject) : void 0;
-  if (classGroupFromNextClassPart) {
-    return classGroupFromNextClassPart;
+  if (nextClassPartObject) {
+    const result = getGroupRecursive(classParts, startIndex + 1, nextClassPartObject);
+    if (result) return result;
   }
-  if (classPartObject.validators.length === 0) {
+  const validators = classPartObject.validators;
+  if (validators === null) {
     return void 0;
   }
-  const classRest = classParts.join(CLASS_PART_SEPARATOR);
-  return classPartObject.validators.find(({
-    validator
-  }) => validator(classRest))?.classGroupId;
-};
-const arbitraryPropertyRegex = /^\[(.+)\]$/;
-const getGroupIdForArbitraryProperty = (className) => {
-  if (arbitraryPropertyRegex.test(className)) {
-    const arbitraryPropertyClassName = arbitraryPropertyRegex.exec(className)[1];
-    const property = arbitraryPropertyClassName?.substring(0, arbitraryPropertyClassName.indexOf(":"));
-    if (property) {
-      return "arbitrary.." + property;
+  const classRest = startIndex === 0 ? classParts.join(CLASS_PART_SEPARATOR) : classParts.slice(startIndex).join(CLASS_PART_SEPARATOR);
+  const validatorsLength = validators.length;
+  for (let i = 0; i < validatorsLength; i++) {
+    const validatorObj = validators[i];
+    if (validatorObj.validator(classRest)) {
+      return validatorObj.classGroupId;
     }
   }
+  return void 0;
 };
+const getGroupIdForArbitraryProperty = (className) => className.slice(1, -1).indexOf(":") === -1 ? void 0 : (() => {
+  const content = className.slice(1, -1);
+  const colonIndex = content.indexOf(":");
+  const property = content.slice(0, colonIndex);
+  return property ? ARBITRARY_PROPERTY_PREFIX + property : void 0;
+})();
 const createClassMap = (config) => {
   const {
     theme,
     classGroups
   } = config;
-  const classMap = {
-    nextPart: /* @__PURE__ */ new Map(),
-    validators: []
-  };
+  return processClassGroups(classGroups, theme);
+};
+const processClassGroups = (classGroups, theme) => {
+  const classMap = createClassPartObject();
   for (const classGroupId in classGroups) {
-    processClassesRecursively(classGroups[classGroupId], classMap, classGroupId, theme);
+    const group = classGroups[classGroupId];
+    processClassesRecursively(group, classMap, classGroupId, theme);
   }
   return classMap;
 };
 const processClassesRecursively = (classGroup, classPartObject, classGroupId, theme) => {
-  classGroup.forEach((classDefinition) => {
-    if (typeof classDefinition === "string") {
-      const classPartObjectToEdit = classDefinition === "" ? classPartObject : getPart(classPartObject, classDefinition);
-      classPartObjectToEdit.classGroupId = classGroupId;
-      return;
-    }
-    if (typeof classDefinition === "function") {
-      if (isThemeGetter(classDefinition)) {
-        processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
-        return;
-      }
-      classPartObject.validators.push({
-        validator: classDefinition,
-        classGroupId
-      });
-      return;
-    }
-    Object.entries(classDefinition).forEach(([key, classGroup2]) => {
-      processClassesRecursively(classGroup2, getPart(classPartObject, key), classGroupId, theme);
-    });
-  });
+  const len = classGroup.length;
+  for (let i = 0; i < len; i++) {
+    const classDefinition = classGroup[i];
+    processClassDefinition(classDefinition, classPartObject, classGroupId, theme);
+  }
+};
+const processClassDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
+  if (typeof classDefinition === "string") {
+    processStringDefinition(classDefinition, classPartObject, classGroupId);
+    return;
+  }
+  if (typeof classDefinition === "function") {
+    processFunctionDefinition(classDefinition, classPartObject, classGroupId, theme);
+    return;
+  }
+  processObjectDefinition(classDefinition, classPartObject, classGroupId, theme);
+};
+const processStringDefinition = (classDefinition, classPartObject, classGroupId) => {
+  const classPartObjectToEdit = classDefinition === "" ? classPartObject : getPart(classPartObject, classDefinition);
+  classPartObjectToEdit.classGroupId = classGroupId;
+};
+const processFunctionDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
+  if (isThemeGetter(classDefinition)) {
+    processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
+    return;
+  }
+  if (classPartObject.validators === null) {
+    classPartObject.validators = [];
+  }
+  classPartObject.validators.push(createClassValidatorObject(classGroupId, classDefinition));
+};
+const processObjectDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
+  const entries = Object.entries(classDefinition);
+  const len = entries.length;
+  for (let i = 0; i < len; i++) {
+    const [key, value] = entries[i];
+    processClassesRecursively(value, getPart(classPartObject, key), classGroupId, theme);
+  }
 };
 const getPart = (classPartObject, path) => {
-  let currentClassPartObject = classPartObject;
-  path.split(CLASS_PART_SEPARATOR).forEach((pathPart) => {
-    if (!currentClassPartObject.nextPart.has(pathPart)) {
-      currentClassPartObject.nextPart.set(pathPart, {
-        nextPart: /* @__PURE__ */ new Map(),
-        validators: []
-      });
+  let current = classPartObject;
+  const parts = path.split(CLASS_PART_SEPARATOR);
+  const len = parts.length;
+  for (let i = 0; i < len; i++) {
+    const part = parts[i];
+    let next = current.nextPart.get(part);
+    if (!next) {
+      next = createClassPartObject();
+      current.nextPart.set(part, next);
     }
-    currentClassPartObject = currentClassPartObject.nextPart.get(pathPart);
-  });
-  return currentClassPartObject;
+    current = next;
+  }
+  return current;
 };
-const isThemeGetter = (func) => func.isThemeGetter;
+const isThemeGetter = (func) => "isThemeGetter" in func && func.isThemeGetter === true;
 const createLruCache = (maxCacheSize) => {
   if (maxCacheSize < 1) {
     return {
@@ -341,31 +527,31 @@ const createLruCache = (maxCacheSize) => {
     };
   }
   let cacheSize = 0;
-  let cache = /* @__PURE__ */ new Map();
-  let previousCache = /* @__PURE__ */ new Map();
+  let cache = /* @__PURE__ */ Object.create(null);
+  let previousCache = /* @__PURE__ */ Object.create(null);
   const update = (key, value) => {
-    cache.set(key, value);
+    cache[key] = value;
     cacheSize++;
     if (cacheSize > maxCacheSize) {
       cacheSize = 0;
       previousCache = cache;
-      cache = /* @__PURE__ */ new Map();
+      cache = /* @__PURE__ */ Object.create(null);
     }
   };
   return {
     get(key) {
-      let value = cache.get(key);
+      let value = cache[key];
       if (value !== void 0) {
         return value;
       }
-      if ((value = previousCache.get(key)) !== void 0) {
+      if ((value = previousCache[key]) !== void 0) {
         update(key, value);
         return value;
       }
     },
     set(key, value) {
-      if (cache.has(key)) {
-        cache.set(key, value);
+      if (key in cache) {
+        cache[key] = value;
       } else {
         update(key, value);
       }
@@ -374,7 +560,14 @@ const createLruCache = (maxCacheSize) => {
 };
 const IMPORTANT_MODIFIER = "!";
 const MODIFIER_SEPARATOR = ":";
-const MODIFIER_SEPARATOR_LENGTH = MODIFIER_SEPARATOR.length;
+const EMPTY_MODIFIERS = [];
+const createResultObject = (modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition, isExternal) => ({
+  modifiers,
+  hasImportantModifier,
+  baseClassName,
+  maybePostfixModifierPosition,
+  isExternal
+});
 const createParseClassName = (config) => {
   const {
     prefix,
@@ -386,12 +579,13 @@ const createParseClassName = (config) => {
     let parenDepth = 0;
     let modifierStart = 0;
     let postfixModifierPosition;
-    for (let index = 0; index < className.length; index++) {
-      let currentCharacter = className[index];
+    const len = className.length;
+    for (let index = 0; index < len; index++) {
+      const currentCharacter = className[index];
       if (bracketDepth === 0 && parenDepth === 0) {
         if (currentCharacter === MODIFIER_SEPARATOR) {
           modifiers.push(className.slice(modifierStart, index));
-          modifierStart = index + MODIFIER_SEPARATOR_LENGTH;
+          modifierStart = index + 1;
           continue;
         }
         if (currentCharacter === "/") {
@@ -399,37 +593,34 @@ const createParseClassName = (config) => {
           continue;
         }
       }
-      if (currentCharacter === "[") {
-        bracketDepth++;
-      } else if (currentCharacter === "]") {
-        bracketDepth--;
-      } else if (currentCharacter === "(") {
-        parenDepth++;
-      } else if (currentCharacter === ")") {
-        parenDepth--;
-      }
+      if (currentCharacter === "[") bracketDepth++;
+      else if (currentCharacter === "]") bracketDepth--;
+      else if (currentCharacter === "(") parenDepth++;
+      else if (currentCharacter === ")") parenDepth--;
+    }
+    const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.slice(modifierStart);
+    let baseClassName = baseClassNameWithImportantModifier;
+    let hasImportantModifier = false;
+    if (baseClassNameWithImportantModifier.endsWith(IMPORTANT_MODIFIER)) {
+      baseClassName = baseClassNameWithImportantModifier.slice(0, -1);
+      hasImportantModifier = true;
+    } else if (
+      /**
+       * In Tailwind CSS v3 the important modifier was at the start of the base class name. This is still supported for legacy reasons.
+       * @see https://github.com/dcastil/tailwind-merge/issues/513#issuecomment-2614029864
+       */
+      baseClassNameWithImportantModifier.startsWith(IMPORTANT_MODIFIER)
+    ) {
+      baseClassName = baseClassNameWithImportantModifier.slice(1);
+      hasImportantModifier = true;
     }
-    const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.substring(modifierStart);
-    const baseClassName = stripImportantModifier(baseClassNameWithImportantModifier);
-    const hasImportantModifier = baseClassName !== baseClassNameWithImportantModifier;
     const maybePostfixModifierPosition = postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : void 0;
-    return {
-      modifiers,
-      hasImportantModifier,
-      baseClassName,
-      maybePostfixModifierPosition
-    };
+    return createResultObject(modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition);
   };
   if (prefix) {
     const fullPrefix = prefix + MODIFIER_SEPARATOR;
     const parseClassNameOriginal = parseClassName;
-    parseClassName = (className) => className.startsWith(fullPrefix) ? parseClassNameOriginal(className.substring(fullPrefix.length)) : {
-      isExternal: true,
-      modifiers: [],
-      hasImportantModifier: false,
-      baseClassName: className,
-      maybePostfixModifierPosition: void 0
-    };
+    parseClassName = (className) => className.startsWith(fullPrefix) ? parseClassNameOriginal(className.slice(fullPrefix.length)) : createResultObject(EMPTY_MODIFIERS, false, className, void 0, true);
   }
   if (experimentalParseClassName) {
     const parseClassNameOriginal = parseClassName;
@@ -440,36 +631,35 @@ const createParseClassName = (config) => {
   }
   return parseClassName;
 };
-const stripImportantModifier = (baseClassName) => {
-  if (baseClassName.endsWith(IMPORTANT_MODIFIER)) {
-    return baseClassName.substring(0, baseClassName.length - 1);
-  }
-  if (baseClassName.startsWith(IMPORTANT_MODIFIER)) {
-    return baseClassName.substring(1);
-  }
-  return baseClassName;
-};
 const createSortModifiers = (config) => {
-  const orderSensitiveModifiers = Object.fromEntries(config.orderSensitiveModifiers.map((modifier) => [modifier, true]));
-  const sortModifiers = (modifiers) => {
-    if (modifiers.length <= 1) {
-      return modifiers;
-    }
-    const sortedModifiers = [];
-    let unsortedModifiers = [];
-    modifiers.forEach((modifier) => {
-      const isPositionSensitive = modifier[0] === "[" || orderSensitiveModifiers[modifier];
-      if (isPositionSensitive) {
-        sortedModifiers.push(...unsortedModifiers.sort(), modifier);
-        unsortedModifiers = [];
+  const modifierWeights = /* @__PURE__ */ new Map();
+  config.orderSensitiveModifiers.forEach((mod, index) => {
+    modifierWeights.set(mod, 1e6 + index);
+  });
+  return (modifiers) => {
+    const result = [];
+    let currentSegment = [];
+    for (let i = 0; i < modifiers.length; i++) {
+      const modifier = modifiers[i];
+      const isArbitrary = modifier[0] === "[";
+      const isOrderSensitive = modifierWeights.has(modifier);
+      if (isArbitrary || isOrderSensitive) {
+        if (currentSegment.length > 0) {
+          currentSegment.sort();
+          result.push(...currentSegment);
+          currentSegment = [];
+        }
+        result.push(modifier);
       } else {
-        unsortedModifiers.push(modifier);
+        currentSegment.push(modifier);
       }
-    });
-    sortedModifiers.push(...unsortedModifiers.sort());
-    return sortedModifiers;
+    }
+    if (currentSegment.length > 0) {
+      currentSegment.sort();
+      result.push(...currentSegment);
+    }
+    return result;
   };
-  return sortModifiers;
 };
 const createConfigUtils = (config) => ({
   cache: createLruCache(config.cacheSize),
@@ -515,29 +705,29 @@ const mergeClassList = (classList, configUtils) => {
       }
       hasPostfixModifier = false;
     }
-    const variantModifier = sortModifiers(modifiers).join(":");
+    const variantModifier = modifiers.length === 0 ? "" : modifiers.length === 1 ? modifiers[0] : sortModifiers(modifiers).join(":");
     const modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier;
     const classId = modifierId + classGroupId;
-    if (classGroupsInConflict.includes(classId)) {
+    if (classGroupsInConflict.indexOf(classId) > -1) {
       continue;
     }
     classGroupsInConflict.push(classId);
     const conflictGroups = getConflictingClassGroupIds(classGroupId, hasPostfixModifier);
-    for (let i2 = 0; i2 < conflictGroups.length; ++i2) {
-      const group = conflictGroups[i2];
+    for (let i = 0; i < conflictGroups.length; ++i) {
+      const group = conflictGroups[i];
       classGroupsInConflict.push(modifierId + group);
     }
     result = originalClassName + (result.length > 0 ? " " + result : result);
   }
   return result;
 };
-function twJoin() {
+const twJoin = (...classLists) => {
   let index = 0;
   let argument;
   let resolvedValue;
   let string = "";
-  while (index < arguments.length) {
-    if (argument = arguments[index++]) {
+  while (index < classLists.length) {
+    if (argument = classLists[index++]) {
       if (resolvedValue = toValue(argument)) {
         string && (string += " ");
         string += resolvedValue;
@@ -545,16 +735,16 @@ function twJoin() {
     }
   }
   return string;
-}
+};
 const toValue = (mix) => {
   if (typeof mix === "string") {
     return mix;
   }
   let resolvedValue;
   let string = "";
-  for (let k2 = 0; k2 < mix.length; k2++) {
-    if (mix[k2]) {
-      if (resolvedValue = toValue(mix[k2])) {
+  for (let k = 0; k < mix.length; k++) {
+    if (mix[k]) {
+      if (resolvedValue = toValue(mix[k])) {
         string && (string += " ");
         string += resolvedValue;
       }
@@ -562,20 +752,20 @@ const toValue = (mix) => {
   }
   return string;
 };
-function createTailwindMerge(createConfigFirst, ...createConfigRest) {
+const createTailwindMerge = (createConfigFirst, ...createConfigRest) => {
   let configUtils;
   let cacheGet;
   let cacheSet;
-  let functionToCall = initTailwindMerge;
-  function initTailwindMerge(classList) {
+  let functionToCall;
+  const initTailwindMerge = (classList) => {
     const config = createConfigRest.reduce((previousConfig, createConfigCurrent) => createConfigCurrent(previousConfig), createConfigFirst());
     configUtils = createConfigUtils(config);
     cacheGet = configUtils.cache.get;
     cacheSet = configUtils.cache.set;
     functionToCall = tailwindMerge;
     return tailwindMerge(classList);
-  }
-  function tailwindMerge(classList) {
+  };
+  const tailwindMerge = (classList) => {
     const cachedResult = cacheGet(classList);
     if (cachedResult) {
       return cachedResult;
@@ -583,13 +773,13 @@ function createTailwindMerge(createConfigFirst, ...createConfigRest) {
     const result = mergeClassList(classList, configUtils);
     cacheSet(classList, result);
     return result;
-  }
-  return function callTailwindMerge() {
-    return functionToCall(twJoin.apply(null, arguments));
   };
-}
+  functionToCall = initTailwindMerge;
+  return (...args) => functionToCall(twJoin(...args));
+};
+const fallbackThemeArr = [];
 const fromTheme = (key) => {
-  const themeGetter = (theme) => theme[key] || [];
+  const themeGetter = (theme) => theme[key] || fallbackThemeArr;
   themeGetter.isThemeGetter = true;
   return themeGetter;
 };
@@ -3226,15 +3416,39 @@ const mergeArrayProperties = (baseObject, mergeObject, key) => {
 };
 const extendTailwindMerge = (configExtension, ...createConfig) => typeof configExtension === "function" ? createTailwindMerge(getDefaultConfig, configExtension, ...createConfig) : createTailwindMerge(() => mergeConfigs(getDefaultConfig(), configExtension), ...createConfig);
 const twMerge = /* @__PURE__ */ createTailwindMerge(getDefaultConfig);
-var f = (e) => x(e) ? twMerge : extendTailwindMerge({ ...e, extend: { theme: e.theme, classGroups: e.classGroups, conflictingClassGroupModifiers: e.conflictingClassGroupModifiers, conflictingClassGroups: e.conflictingClassGroups, ...e.extend } }), i = (...e) => (a2) => {
-  let t = u(e);
-  return !t || !a2.twMerge ? t : ((!S.cachedTwMerge || S.didTwMergeConfigChange) && (S.didTwMergeConfigChange = false, S.cachedTwMerge = f(S.cachedTwMergeConfig)), S.cachedTwMerge(t) || void 0);
+var createTwMerge = (cachedTwMergeConfig) => {
+  return isEmptyObject(cachedTwMergeConfig) ? twMerge : extendTailwindMerge({
+    ...cachedTwMergeConfig,
+    extend: {
+      theme: cachedTwMergeConfig.theme,
+      classGroups: cachedTwMergeConfig.classGroups,
+      conflictingClassGroupModifiers: cachedTwMergeConfig.conflictingClassGroupModifiers,
+      conflictingClassGroups: cachedTwMergeConfig.conflictingClassGroups,
+      ...cachedTwMergeConfig.extend
+    }
+  });
+};
+var executeMerge = (classnames, config) => {
+  const base = cx(classnames);
+  if (!base || !(config?.twMerge ?? true)) return base;
+  if (!state.cachedTwMerge || state.didTwMergeConfigChange) {
+    state.didTwMergeConfigChange = false;
+    state.cachedTwMerge = createTwMerge(state.cachedTwMergeConfig);
+  }
+  return state.cachedTwMerge(base) || void 0;
+};
+var cn = (...classnames) => {
+  return executeMerge(classnames, {});
+};
+var cnMerge = (...classnames) => {
+  return (config) => executeMerge(classnames, config);
 };
-var { createTV: C, tv: T } = le(i);
+var { createTV, tv } = getTailwindVariants(cnMerge);
 export {
-  C,
-  Q,
-  T,
-  i,
-  u
+  cnMerge as a,
+  createTV as b,
+  cn as c,
+  defaultConfig as d,
+  cx as e,
+  tv as t
 };