@chaibuilder/sdk 1.0.13 → 1.0.15

package/dist/{Class-l7qYbuoN.js → Class-nQk08vqd.js}

@@ -1,6 +1,77 @@
-import { range as o, map as r, values as b, flattenDeep as l, flatten as f, isEmpty as g, startsWith as m, get as x } from "lodash";
-import { M as E } from "./MODIFIERS-DsEzQ3aH.js";
-const d = [
+import { clsx as f } from "clsx";
+import { twMerge as m } from "tailwind-merge";
+import { isEmpty as g, startsWith as E, range as o, map as r, values as b, flattenDeep as n, flatten as h, get as x } from "lodash";
+var D = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function I(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+const W = (...e) => m(f(e));
+function T(e = 6, s = "abcdefghijklmnopqrstuvwxyzABCD") {
+  let a = "";
+  for (let l = e; l > 0; --l)
+    a += s[Math.floor(Math.random() * s.length)];
+  return a;
+}
+const Y = (e) => e >= 1536 ? "2XL" : e >= 1280 ? "XL" : e >= 1024 ? "LG" : e >= 768 ? "MD" : e >= 640 ? "SM" : "XS", X = "#styles:", P = "#slots:", F = "#i18n", y = [
+  "hover",
+  "focus",
+  "focus-within",
+  "focus-visible",
+  "active",
+  "visited",
+  "target",
+  "first",
+  "last",
+  "only",
+  "odd",
+  "even",
+  "first-of-type",
+  "last-of-type",
+  "only-of-type",
+  "empty",
+  "disabled",
+  "checked",
+  "indeterminate",
+  "default",
+  "required",
+  "valid",
+  "invalid",
+  "in-range",
+  "out-of-range",
+  "placeholder-shown",
+  "autofill",
+  "read-only",
+  "open",
+  "before",
+  "after",
+  "first-letter",
+  "first-line",
+  "marker",
+  "selection",
+  "file",
+  "placeholder",
+  // headless UI
+  "ui-open",
+  "ui-disabled",
+  "ui-active",
+  "ui-selected",
+  "ui-checked",
+  "ui-not-open",
+  "ui-not-disabled",
+  "ui-not-active",
+  "ui-not-selected",
+  "ui-not-checked"
+], _ = {
+  bodyFont: "Inter",
+  headingFont: "Inter",
+  roundedCorners: 5,
+  primaryColor: "#570df8",
+  secondaryColor: "#f002b8",
+  bodyBgDarkColor: "#031022",
+  bodyBgLightColor: "#fcfcfc",
+  bodyTextDarkColor: "#ffffff",
+  bodyTextLightColor: "#000000"
+}, d = [
   0,
   1,
   2,
@@ -31,7 +102,7 @@ const d = [
   72,
   80,
   96
-], s = {
+], t = {
   columns: [...o(1, 13), "auto", "3xs", "2xs", "xs", "sm", "md", "lg", "xl", ...r(o(2, 8), (e) => `${e}xl`)],
   breakAfter: ["auto", "avoid", "all", "avoid-page", "page", "left", "right", "column"],
   breakInside: ["auto", "avoid", "avoid-page", "avoid-column"],
@@ -70,19 +141,19 @@ const d = [
     regExp: "container"
   },
   columns: {
-    classes: r(s.columns, (e) => `columns-${e}`),
+    classes: r(t.columns, (e) => `columns-${e}`),
     regExp: "columns-(auto|[0-9]xl|[0-9]xs|xs|sm|md|lg|xl|\\d+)"
   },
   breakAfter: {
-    classes: r(s.breakAfter, (e) => `break-after-${e}`),
+    classes: r(t.breakAfter, (e) => `break-after-${e}`),
     regExp: "break-after-\\S+"
   },
   breakBefore: {
-    classes: r(s.breakAfter, (e) => `break-before-${e}`),
+    classes: r(t.breakAfter, (e) => `break-before-${e}`),
     regExp: "break-before-\\S+"
   },
   breakInside: {
-    classes: r(s.breakInside, (e) => `break-inside-${e}`),
+    classes: r(t.breakInside, (e) => `break-inside-${e}`),
     regExp: "break-inside-\\S+"
   },
   boxDecoration: {
@@ -122,21 +193,21 @@ const d = [
     regExp: "border-(solid|dashed|dotted|double|hidden|none)"
   },
   overflow: {
-    classes: r(s.overflow, (e) => `overflow-${e}`),
-    regExp: `overflow-(${s.overflow.join("|")})`
+    classes: r(t.overflow, (e) => `overflow-${e}`),
+    regExp: `overflow-(${t.overflow.join("|")})`
   },
   overflowX: {
-    classes: r(s.overflow, (e) => `overflow-x-${e}`),
-    regExp: `overflow-x-(${s.overflow.join("|")})`
+    classes: r(t.overflow, (e) => `overflow-x-${e}`),
+    regExp: `overflow-x-(${t.overflow.join("|")})`
   },
   overflowY: {
-    classes: r(s.overflow, (e) => `overflow-y-${e}`),
-    regExp: `overflow-y-(${s.overflow.join("|")})`
+    classes: r(t.overflow, (e) => `overflow-y-${e}`),
+    regExp: `overflow-y-(${t.overflow.join("|")})`
   },
   gridRows: { classes: r([1, 2, 3, 4, 5, 6, "none"], (e) => `grid-rows-${e}`), regExp: "grid-rows-(\\d|none)" },
   display: {
-    classes: r(s.display, (e) => e.toString()),
-    regExp: `(${s.display.join("|")})`
+    classes: r(t.display, (e) => e.toString()),
+    regExp: `(${t.display.join("|")})`
   },
   float: {
     classes: ["float-right", "float-left", "float-none"],
@@ -151,83 +222,83 @@ const d = [
     regExp: "isolate|isolation-auto"
   },
   objectFit: {
-    classes: r(s.objectFit, (e) => `object-${e}`),
+    classes: r(t.objectFit, (e) => `object-${e}`),
     regExp: "object-(contain|cover|fill|none|scale-down)"
   },
   objectPosition: {
-    classes: r(s.objectPosition, (e) => `object-${e}`),
-    regExp: `object-(${s.objectPosition.join("|")})`
+    classes: r(t.objectPosition, (e) => `object-${e}`),
+    regExp: `object-(${t.objectPosition.join("|")})`
   },
   overscroll: {
-    classes: r(s.overscroll, (e) => `overscroll-${e}`),
-    regExp: `overscroll-(${s.overscroll.join("|")})`
+    classes: r(t.overscroll, (e) => `overscroll-${e}`),
+    regExp: `overscroll-(${t.overscroll.join("|")})`
   },
   overscrollX: {
-    classes: r(s.overscroll, (e) => `overscroll-x-${e}`),
-    regExp: `overscroll-x-(${s.overscroll.join("|")})`
+    classes: r(t.overscroll, (e) => `overscroll-x-${e}`),
+    regExp: `overscroll-x-(${t.overscroll.join("|")})`
   },
   overscrollY: {
-    classes: r(s.overscroll, (e) => `overscroll-y-${e}`),
-    regExp: `overscroll-y-(${s.overscroll.join("|")})`
+    classes: r(t.overscroll, (e) => `overscroll-y-${e}`),
+    regExp: `overscroll-y-(${t.overscroll.join("|")})`
   },
   inset: {
-    classes: r(s.trbl, (e) => `inset-${e}`),
+    classes: r(t.trbl, (e) => `inset-${e}`),
     regExp: "-?inset-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   insetX: {
-    classes: r(s.trbl, (e) => `inset-x-${e}`),
+    classes: r(t.trbl, (e) => `inset-x-${e}`),
     regExp: "-?inset-x-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   insetY: {
-    classes: r(s.trbl, (e) => `inset-y-${e}`),
+    classes: r(t.trbl, (e) => `inset-y-${e}`),
     regExp: "-?inset-y-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   top: {
-    classes: r(s.trbl, (e) => `top-${e}`),
+    classes: r(t.trbl, (e) => `top-${e}`),
     regExp: "-?top-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   topX: {
-    classes: r(s.trbl, (e) => `top-x-${e}`),
+    classes: r(t.trbl, (e) => `top-x-${e}`),
     regExp: "-?top-x-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   topY: {
-    classes: r(s.trbl, (e) => `top-y-${e}`),
+    classes: r(t.trbl, (e) => `top-y-${e}`),
     regExp: "-?top-y-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   right: {
-    classes: r(s.trbl, (e) => `right-${e}`),
+    classes: r(t.trbl, (e) => `right-${e}`),
     regExp: "-?right-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   rightX: {
-    classes: r(s.trbl, (e) => `right-x-${e}`),
+    classes: r(t.trbl, (e) => `right-x-${e}`),
     regExp: "-?right-x-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   rightY: {
-    classes: r(s.trbl, (e) => `right-y-${e}`),
+    classes: r(t.trbl, (e) => `right-y-${e}`),
     regExp: "-?right-y-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   bottom: {
-    classes: r(s.trbl, (e) => `bottom-${e}`),
+    classes: r(t.trbl, (e) => `bottom-${e}`),
     regExp: "-?bottom-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   bottomX: {
-    classes: r(s.trbl, (e) => `bottom-x-${e}`),
+    classes: r(t.trbl, (e) => `bottom-x-${e}`),
     regExp: "-?bottom-x-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   bottomY: {
-    classes: r(s.trbl, (e) => `bottom-y-${e}`),
+    classes: r(t.trbl, (e) => `bottom-y-${e}`),
     regExp: "-?bottom-y-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   left: {
-    classes: r(s.trbl, (e) => `left-${e}`),
+    classes: r(t.trbl, (e) => `left-${e}`),
     regExp: "-?left-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   leftX: {
-    classes: r(s.trbl, (e) => `left-x-${e}`),
+    classes: r(t.trbl, (e) => `left-x-${e}`),
     regExp: "-?left-x-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   leftY: {
-    classes: r(s.trbl, (e) => `left-y-${e}`),
+    classes: r(t.trbl, (e) => `left-y-${e}`),
     regExp: "-?left-y-(px|\\d\\/\\d|\\d\\.\\d|\\d+|full|auto|\\[.*\\])"
   },
   visibility: {
@@ -240,7 +311,7 @@ const d = [
   },
   // Flex box and grids
   flexBasis: {
-    classes: r(s.flexBasis, (e) => `basis-${e}`),
+    classes: r(t.flexBasis, (e) => `basis-${e}`),
     regExp: "basis-(\\d+|\\S+)"
   },
   flexGrow: { classes: ["grow", "grow-0"], regExp: "grow(-0)?" },
@@ -278,9 +349,9 @@ const d = [
     classes: ["auto-rows-auto", "auto-rows-min", "auto-rows-max", "auto-rows-fr"],
     regExp: "auto-rows-(auto|min|max|fr)"
   },
-  gap: { classes: r(s.indent, (e) => `gap-${e}`), regExp: "gap-(px|\\d.\\d|\\d|\\[.*\\])" },
-  gapX: { classes: r(s.indent, (e) => `gap-x-${e}`), regExp: "gap-x-(px|\\d.\\d|\\d|\\[.*\\])" },
-  gapY: { classes: r(s.indent, (e) => `gap-y-${e}`), regExp: "gap-y-(px|\\d.\\d|\\d|\\[.*\\])" },
+  gap: { classes: r(t.indent, (e) => `gap-${e}`), regExp: "gap-(px|\\d.\\d|\\d|\\[.*\\])" },
+  gapX: { classes: r(t.indent, (e) => `gap-x-${e}`), regExp: "gap-x-(px|\\d.\\d|\\d|\\[.*\\])" },
+  gapY: { classes: r(t.indent, (e) => `gap-y-${e}`), regExp: "gap-y-(px|\\d.\\d|\\d|\\[.*\\])" },
   justifyContent: {
     classes: ["justify-start", "justify-end", "justify-center", "justify-between", "justify-around", "justify-evenly"],
     regExp: "justify-(start|end|center|between|around|evenly)"
@@ -381,36 +452,36 @@ const d = [
     regExp: "bg-origin-(border|padding|content)"
   },
   transformOrigin: {
-    classes: r(s.origin, (e) => `origin-${e}`),
+    classes: r(t.origin, (e) => `origin-${e}`),
     regExp: "origin-(\\d+|\\S+)"
   },
   // spacing
   padding: {
-    classes: r(s.padding, (e) => `p-${e}`),
+    classes: r(t.padding, (e) => `p-${e}`),
     regExp: "p-(\\d+|\\S+|\\[.*\\])"
   },
   paddingX: {
-    classes: r(s.padding, (e) => `px-${e}`),
+    classes: r(t.padding, (e) => `px-${e}`),
     regExp: "px-(\\d+|\\S+|\\[.*\\])"
   },
   paddingY: {
-    classes: r(s.padding, (e) => `py-${e}`),
+    classes: r(t.padding, (e) => `py-${e}`),
     regExp: "py-(\\d+|\\S+|\\[.*\\])"
   },
   paddingTop: {
-    classes: r(s.padding, (e) => `pt-${e}`),
+    classes: r(t.padding, (e) => `pt-${e}`),
     regExp: "pt-(\\d+|\\S+|\\[.*\\])"
   },
   paddingRight: {
-    classes: r(s.padding, (e) => `pr-${e}`),
+    classes: r(t.padding, (e) => `pr-${e}`),
     regExp: "pr-(\\d+|\\S+|\\[.*\\])"
   },
   paddingBottom: {
-    classes: r(s.padding, (e) => `pb-${e}`),
+    classes: r(t.padding, (e) => `pb-${e}`),
     regExp: "pb-(\\d+|\\S+|\\[.*\\])"
   },
   paddingLeft: {
-    classes: r(s.padding, (e) => `pl-${e}`),
+    classes: r(t.padding, (e) => `pl-${e}`),
     regExp: "pl-(\\d+|\\S+|\\[.*\\])"
   },
   textDecorationStyle: {
@@ -426,39 +497,39 @@ const d = [
     regExp: "from-(black|transparent|current|white|primary(-\\d+)?|secondary(-\\d+)?|\\S+-\\d+)"
   },
   margin: {
-    classes: r(s.margin, (e) => `m-${e}`),
+    classes: r(t.margin, (e) => `m-${e}`),
     regExp: "-?m-(\\d+|\\S+|\\[.*\\])"
   },
   marginX: {
-    classes: r(s.margin, (e) => `mx-${e}`),
+    classes: r(t.margin, (e) => `mx-${e}`),
     regExp: "-?mx-(\\d+|\\S+|\\[.*\\])"
   },
   marginY: {
-    classes: r(s.margin, (e) => `my-${e}`),
+    classes: r(t.margin, (e) => `my-${e}`),
     regExp: "-?my-(\\d+|\\S+|\\[.*\\])"
   },
   marginTop: {
-    classes: r(s.margin, (e) => `mt-${e}`),
+    classes: r(t.margin, (e) => `mt-${e}`),
     regExp: "-?mt-(\\d+|\\S+|\\[.*\\])"
   },
   marginRight: {
-    classes: r(s.margin, (e) => `mr-${e}`),
+    classes: r(t.margin, (e) => `mr-${e}`),
     regExp: "-?mr-(\\d+|\\S+|\\[.*\\])"
   },
   marginBottom: {
-    classes: r(s.margin, (e) => `mb-${e}`),
+    classes: r(t.margin, (e) => `mb-${e}`),
     regExp: "-?mb-(\\d+|\\S+|\\[.*\\])"
   },
   marginLeft: {
-    classes: r(s.margin, (e) => `ml-${e}`),
+    classes: r(t.margin, (e) => `ml-${e}`),
     regExp: "-?ml-(\\d+|\\S+|\\[.*\\])"
   },
   spaceX: {
-    classes: r(s.space, (e) => `space-x-${e}`),
+    classes: r(t.space, (e) => `space-x-${e}`),
     regExp: "-?space-x-(\\d+|\\S+|\\[.*\\])"
   },
   spaceY: {
-    classes: r(s.space, (e) => `space-y-${e}`),
+    classes: r(t.space, (e) => `space-y-${e}`),
     regExp: "-?space-y-(\\d+|\\S+|\\[.*\\])"
   },
   boxShadow: {
@@ -471,11 +542,11 @@ const d = [
     regExp: "min-w-(\\d+|\\S+|\\[.*\\])"
   },
   maxWidth: {
-    classes: r(s.maxWidth, (e) => `max-w-${e}`),
+    classes: r(t.maxWidth, (e) => `max-w-${e}`),
     regExp: "max-w-(\\d+|\\S+|\\[.*\\])"
   },
   width: {
-    classes: r([...s.width, "full", "screen", "min", "max", "fit"], (e) => `w-${e}`),
+    classes: r([...t.width, "full", "screen", "min", "max", "fit"], (e) => `w-${e}`),
     regExp: "w-(\\d+.\\d+|\\d+|px|auto|full|screen|min|max|fit|\\[.*\\])"
   },
   minHeight: {
@@ -483,11 +554,11 @@ const d = [
     regExp: "min-h-(\\d+|\\S+|\\[.*\\])"
   },
   maxHeight: {
-    classes: r(s.maxHeight, (e) => `max-h-${e}`),
+    classes: r(t.maxHeight, (e) => `max-h-${e}`),
     regExp: "max-h-(\\d+|\\S+|\\[.*\\])"
   },
   height: {
-    classes: r(s.height, (e) => `h-${e}`),
+    classes: r(t.height, (e) => `h-${e}`),
     regExp: "h-(\\d+.\\d+|\\d+|px|auto|full|screen|min|max|fit|\\[.*\\])"
   },
   // typography
@@ -629,7 +700,7 @@ const d = [
     regExp: "uppercase|lowercase|capitalize|normal-case"
   },
   textIndent: {
-    classes: r(s.indent, (e) => `indent-${e}`),
+    classes: r(t.indent, (e) => `indent-${e}`),
     regExp: "-?indent-(\\d+|\\S+)"
   },
   whitespace: {
@@ -705,63 +776,63 @@ const d = [
   },
   // border
   borderRadiusTopLeft: {
-    classes: ["rounded-tl", ...r(s.borderRadius, (e) => `rounded-tl-${e}`)],
+    classes: ["rounded-tl", ...r(t.borderRadius, (e) => `rounded-tl-${e}`)],
     regExp: "rounded-tl-?(\\d+|\\S+)?"
   },
   borderRadiusTopRight: {
-    classes: ["rounded-tr", ...r(s.borderRadius, (e) => `rounded-tr-${e}`)],
+    classes: ["rounded-tr", ...r(t.borderRadius, (e) => `rounded-tr-${e}`)],
     regExp: "rounded-tr-?(\\d+|\\S+)?"
   },
   borderRadiusBottomRight: {
-    classes: ["rounded-br", ...r(s.borderRadius, (e) => `rounded-br-${e}`)],
+    classes: ["rounded-br", ...r(t.borderRadius, (e) => `rounded-br-${e}`)],
     regExp: "rounded-br-?(\\d+|\\S+)?"
   },
   borderRadiusBottomLeft: {
-    classes: ["rounded-bl", ...r(s.borderRadius, (e) => `rounded-bl-${e}`)],
+    classes: ["rounded-bl", ...r(t.borderRadius, (e) => `rounded-bl-${e}`)],
     regExp: "rounded-bl-?(\\d+|\\S+)?"
   },
   borderRadiusTop: {
-    classes: ["rounded-t", ...r(s.borderRadius, (e) => `rounded-t-${e}`)],
+    classes: ["rounded-t", ...r(t.borderRadius, (e) => `rounded-t-${e}`)],
     regExp: "rounded-t-?(\\d+|\\S+)?"
   },
   borderRadiusRight: {
-    classes: ["rounded-r", ...r(s.borderRadius, (e) => `rounded-r-${e}`)],
+    classes: ["rounded-r", ...r(t.borderRadius, (e) => `rounded-r-${e}`)],
     regExp: "rounded-r-?(\\d+|\\S+)?"
   },
   borderRadiusBottom: {
-    classes: ["rounded-b", ...r(s.borderRadius, (e) => `rounded-b-${e}`)],
+    classes: ["rounded-b", ...r(t.borderRadius, (e) => `rounded-b-${e}`)],
     regExp: "rounded-b-?(\\d+|\\S+)?"
   },
   borderRadiusLeft: {
-    classes: ["rounded-l", ...r(s.borderRadius, (e) => `rounded-l-${e}`)],
-    regExp: `(rounded-l-(${s.borderRadius.join("|")})|rounded-l$)`
+    classes: ["rounded-l", ...r(t.borderRadius, (e) => `rounded-l-${e}`)],
+    regExp: `(rounded-l-(${t.borderRadius.join("|")})|rounded-l$)`
   },
   borderRadius: {
-    classes: ["rounded", ...r(s.borderRadius, (e) => `rounded-${e}`)],
-    regExp: `(rounded-(${s.borderRadius.join("|")}$)|rounded)`
+    classes: ["rounded", ...r(t.borderRadius, (e) => `rounded-${e}`)],
+    regExp: `(rounded-(${t.borderRadius.join("|")}$)|rounded)`
   },
   borderX: {
-    classes: ["border-x", ...r(s.borderWidth, (e) => `border-x-${e}`)],
+    classes: ["border-x", ...r(t.borderWidth, (e) => `border-x-${e}`)],
     regExp: "border-x-?(\\d+|\\S+|\\[.*\\])?"
   },
   borderY: {
-    classes: ["border-y", ...r(s.borderWidth, (e) => `border-y-${e}`)],
+    classes: ["border-y", ...r(t.borderWidth, (e) => `border-y-${e}`)],
     regExp: "border-y-?(\\d+|\\S+|\\[.*\\])?"
   },
   borderTop: {
-    classes: ["border-t", ...r(s.borderWidth, (e) => `border-t-${e}`)],
+    classes: ["border-t", ...r(t.borderWidth, (e) => `border-t-${e}`)],
     regExp: "border-t-?(\\d+|\\S+|\\[.*\\])?"
   },
   borderRight: {
-    classes: ["border-r", ...r(s.borderWidth, (e) => `border-r-${e}`)],
+    classes: ["border-r", ...r(t.borderWidth, (e) => `border-r-${e}`)],
     regExp: "border-r-?(\\d+|\\S+|\\[.*\\])?"
   },
   borderBottom: {
-    classes: ["border-b", ...r(s.borderWidth, (e) => `border-b-${e}`)],
+    classes: ["border-b", ...r(t.borderWidth, (e) => `border-b-${e}`)],
     regExp: "border-b-?(\\d+|\\S+|\\[.*\\])?"
   },
   borderLeft: {
-    classes: ["border-l", ...r(s.borderWidth, (e) => `border-l-${e}`)],
+    classes: ["border-l", ...r(t.borderWidth, (e) => `border-l-${e}`)],
     regExp: "border-l-?(\\d+|\\S+|\\[.*\\])?"
   },
   borderColor: {
@@ -769,7 +840,7 @@ const d = [
     regExp: "border-(black|transparent|current|white|primary(-\\d+)?|secondary(-\\d+)?|\\S+-\\d+)"
   },
   border: {
-    classes: ["border", ...r(s.borderWidth, (e) => `border-${e}`)],
+    classes: ["border", ...r(t.borderWidth, (e) => `border-${e}`)],
     regExp: "border-?(\\d+|\\S+|\\[.*\\])?"
   },
   order: {
@@ -831,11 +902,11 @@ const d = [
     regExp: "opacity-(\\d+|\\[.*\\])"
   },
   mixBlendMode: {
-    classes: r(s.blendEffect, (e) => `mix-blend-${e}`),
+    classes: r(t.blendEffect, (e) => `mix-blend-${e}`),
     regExp: "mix-blend-(\\d+|\\S+)"
   },
   bgBlendMode: {
-    classes: r(s.blendEffect, (e) => `bg-blend-${e}`),
+    classes: r(t.blendEffect, (e) => `bg-blend-${e}`),
     regExp: "bg-blend-(\\d+|\\S+)"
   },
   // filters
@@ -895,15 +966,15 @@ const d = [
     regExp: "animation-(none|spin|ping)"
   },
   scaleX: {
-    classes: r(s.scale, (e) => `scale-x-${e}`),
+    classes: r(t.scale, (e) => `scale-x-${e}`),
     regExp: "-?scale-x-(\\d+|\\S+|\\[.*\\])"
   },
   scaleY: {
-    classes: r(s.scale, (e) => `scale-y-${e}`),
+    classes: r(t.scale, (e) => `scale-y-${e}`),
     regExp: "-?scale-y-(\\d+|\\S+|\\[.*\\])"
   },
   scale: {
-    classes: r(s.scale, (e) => `scale-${e}`),
+    classes: r(t.scale, (e) => `scale-${e}`),
     regExp: "-?scale-(\\d+|\\S+|\\[.*\\])"
   },
   rotate: {
@@ -967,7 +1038,7 @@ const d = [
     classes: ["stroke-0", "stroke-1", "stroke-2"],
     regExp: "stroke-(\\d+|\\[.*\\])"
   }
-}, h = {
+}, w = {
   backgroundColor: "bg",
   textColor: "text",
   borderColor: "border",
@@ -979,7 +1050,7 @@ const d = [
   toColor: "to",
   ringColor: "ring",
   ringOffsetColor: "ring-offset"
-}, y = ["current", "inherit", "transparent", "black", "white", "primary", "secondary"], w = ["primary", "secondary"], $ = [
+}, $ = ["current", "inherit", "transparent", "black", "white", "primary", "secondary"], k = ["primary", "secondary"], S = [
   "slate",
   "gray",
   "zinc",
@@ -1002,70 +1073,79 @@ const d = [
   "fuchsia",
   "pink",
   "rose"
-], u = ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900"], i = r(b(h), (e) => e), k = l([
-  ...r(y, (e) => f(r(i, (t) => `${t}-${e}`))),
+], u = ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900"], i = r(b(w), (e) => e), v = n([
+  ...r($, (e) => h(r(i, (s) => `${s}-${e}`))),
   ...r(
-    w,
-    (e) => l(r(i, (t) => l(r(u, (a) => `${t}-${e}-${a}`))))
+    k,
+    (e) => n(r(i, (s) => n(r(u, (a) => `${s}-${e}-${a}`))))
   ),
   ...r(
-    $,
-    (e) => l(r(i, (t) => l(r(u, (a) => `${t}-${e}-${a}`))))
+    S,
+    (e) => n(r(i, (s) => n(r(u, (a) => `${s}-${e}-${a}`))))
   )
-]), A = r(
-  l(
-    b(p).map((e) => e.classes).concat(k)
+]), N = r(
+  n(
+    b(p).map((e) => e.classes).concat(v)
   ),
   (e) => ({
     name: e
   })
 );
-function S(e) {
+function C(e) {
   if (g(e.trim()))
     return "";
-  const t = e.match(/sm:|md:|lg:|xl:|2xl:/g);
-  return x(t, 0, "xs").replace(":", "");
+  const s = e.match(/sm:|md:|lg:|xl:|2xl:/g);
+  return x(s, 0, "xs").replace(":", "");
 }
-function v(e) {
-  const t = r(E, (n) => `${n}:`).join("|"), a = new RegExp(t, "g");
+function j(e) {
+  const s = r(y, (l) => `${l}:`).join("|"), a = new RegExp(s, "g");
   return x(a.exec(e.trim()), 0, "").replace(":", "");
 }
-function C(e) {
+function R(e) {
   return e.trim().split(":").pop() || "";
 }
 const c = {};
-function R(e) {
+function L(e) {
   if (g(e))
     return "";
   if (c[e])
     return c[e];
-  let t = "";
+  let s = "";
   for (const a in p) {
-    const n = x(p, `${a}.regExp`, "");
-    if (new RegExp(n, "g").test(e)) {
-      t = a, c[e] = t;
+    const l = x(p, `${a}.regExp`, "");
+    if (new RegExp(l, "g").test(e)) {
+      s = a, c[e] = s;
       break;
     }
   }
-  return t;
+  return s;
 }
-function L(e) {
+function z(e) {
   return g(e) ? null : {
-    dark: m(e, "dark:"),
-    mq: S(e),
-    mod: v(e),
-    cls: C(e),
+    dark: E(e, "dark:"),
+    mq: C(e),
+    mod: j(e),
+    cls: R(e),
     fullCls: e,
-    property: R(e)
+    property: L(e)
   };
 }
-function X(e) {
-  let t = "";
-  return e.dark && (t += "dark:"), e.mq.toLowerCase() !== "xs" && (t += `${e.mq}:`), e.mod && (t += `${e.mod}:`), t += e.cls, t;
+function M(e) {
+  let s = "";
+  return e.dark && (s += "dark:"), e.mq.toLowerCase() !== "xs" && (s += `${e.mq}:`), e.mod && (s += `${e.mod}:`), s += e.cls, s;
 }
 export {
-  A,
+  N as A,
+  _ as B,
   p as C,
-  L as c,
-  X as g
+  F as I,
+  P as S,
+  X as a,
+  W as b,
+  D as c,
+  T as d,
+  z as e,
+  Y as f,
+  I as g,
+  M as h
 };